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 #ifndef SWIGCSHARP
  12 #define SWIGCSHARP
  13 #endif
  14
  15 #define SWIG_DIRECTORS
  16
  17 #ifdef __cplusplus
  18 /* SwigValueWrapper is described in swig.swg */
  19 template<typename T> class SwigValueWrapper {
  20   struct SwigMovePointer {
  21     T *ptr;
  22     SwigMovePointer(T *p) : ptr(p) { }
  23     ~SwigMovePointer() { delete ptr; }
  24     SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  25   } pointer;
  26   SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  27   SwigValueWrapper(const SwigValueWrapper<T>& rhs);
  28 public:
  29   SwigValueWrapper() : pointer(0) { }
  30   SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  31   operator T&() const { return *pointer.ptr; }
  32   T *operator&() { return pointer.ptr; }
  33 };
  34
  35 template <typename T> T SwigValueInit() {
  36   return T();
  37 }
  38 #endif
  39
  40 /* -----------------------------------------------------------------------------
  41  *  This section contains generic SWIG labels for method/variable
  42  *  declarations/attributes, and other compiler dependent labels.
  43  * ----------------------------------------------------------------------------- */
  44
  45 /* template workaround for compilers that cannot correctly implement the C++ standard */
  46 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  47 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
  48 #  define SWIGTEMPLATEDISAMBIGUATOR template
  49 # elif defined(__HP_aCC)
  50 /* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
  51 /* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
  52 #  define SWIGTEMPLATEDISAMBIGUATOR template
  53 # else
  54 #  define SWIGTEMPLATEDISAMBIGUATOR
  55 # endif
  56 #endif
  57
  58 /* inline attribute */
  59 #ifndef SWIGINLINE
  60 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  61 #   define SWIGINLINE inline
  62 # else
  63 #   define SWIGINLINE
  64 # endif
  65 #endif
  66
  67 /* attribute recognised by some compilers to avoid 'unused' warnings */
  68 #ifndef SWIGUNUSED
  69 # if defined(__GNUC__)
  70 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  71 #     define SWIGUNUSED __attribute__ ((__unused__))
  72 #   else
  73 #     define SWIGUNUSED
  74 #   endif
  75 # elif defined(__ICC)
  76 #   define SWIGUNUSED __attribute__ ((__unused__))
  77 # else
  78 #   define SWIGUNUSED
  79 # endif
  80 #endif
  81
  82 #ifndef SWIG_MSC_UNSUPPRESS_4505
  83 # if defined(_MSC_VER)
  84 #   pragma warning(disable : 4505) /* unreferenced local function has been removed */
  85 # endif
  86 #endif
  87
  88 #ifndef SWIGUNUSEDPARM
  89 # ifdef __cplusplus
  90 #   define SWIGUNUSEDPARM(p)
  91 # else
  92 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  93 # endif
  94 #endif
  95
  96 /* internal SWIG method */
  97 #ifndef SWIGINTERN
  98 # define SWIGINTERN static SWIGUNUSED
  99 #endif
 100
 101 /* internal inline SWIG method */
 102 #ifndef SWIGINTERNINLINE
 103 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
 104 #endif
 105
 106 /* exporting methods */
 107 #if defined(__GNUC__)
 108 #  if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 109 #    ifndef GCC_HASCLASSVISIBILITY
 110 #      define GCC_HASCLASSVISIBILITY
 111 #    endif
 112 #  endif
 113 #endif
 114
 115 #ifndef SWIGEXPORT
 116 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 117 #   if defined(STATIC_LINKED)
 118 #     define SWIGEXPORT
 119 #   else
 120 #     define SWIGEXPORT __declspec(dllexport)
 121 #   endif
 122 # else
 123 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
 124 #     define SWIGEXPORT __attribute__ ((visibility("default")))
 125 #   else
 126 #     define SWIGEXPORT
 127 #   endif
 128 # endif
 129 #endif
 130
 131 /* calling conventions for Windows */
 132 #ifndef SWIGSTDCALL
 133 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
 134 #   define SWIGSTDCALL __stdcall
 135 # else
 136 #   define SWIGSTDCALL
 137 # endif
 138 #endif
 139
 140 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 141 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 142 # define _CRT_SECURE_NO_DEPRECATE
 143 #endif
 144
 145 /* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
 146 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
 147 # define _SCL_SECURE_NO_DEPRECATE
 148 #endif
 149
 150 /* Deal with Apple's deprecated 'AssertMacros.h' from Carbon-framework */
 151 #if defined(__APPLE__) && !defined(__ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES)
 152 # define __ASSERT_MACROS_DEFINE_VERSIONS_WITHOUT_UNDERSCORES 0
 153 #endif
 154
 155 /* Intel's compiler complains if a variable which was never initialised is
 156  * cast to void, which is a common idiom which we use to indicate that we
 157  * are aware a variable isn't used.  So we just silence that warning.
 158  * See: https://github.com/swig/swig/issues/192 for more discussion.
 159  */
 160 #ifdef __INTEL_COMPILER
 161 # pragma warning disable 592
 162 #endif
 163
 164
 165 #include <stdlib.h>
 166 #include <string.h>
 167 #include <stdio.h>
 168
 169 /* Support for throwing C# exceptions from C/C++. There are two types:
 170  * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
 171 typedef enum {
 172   SWIG_CSharpApplicationException,
 173   SWIG_CSharpArithmeticException,
 174   SWIG_CSharpDivideByZeroException,
 175   SWIG_CSharpIndexOutOfRangeException,
 176   SWIG_CSharpInvalidCastException,
 177   SWIG_CSharpInvalidOperationException,
 178   SWIG_CSharpIOException,
 179   SWIG_CSharpNullReferenceException,
 180   SWIG_CSharpOutOfMemoryException,
 181   SWIG_CSharpOverflowException,
 182   SWIG_CSharpSystemException
 183 } SWIG_CSharpExceptionCodes;
 184
 185 typedef enum {
 186   SWIG_CSharpArgumentException,
 187   SWIG_CSharpArgumentNullException,
 188   SWIG_CSharpArgumentOutOfRangeException
 189 } SWIG_CSharpExceptionArgumentCodes;
 190
 191 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
 192 typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);
 193
 194 typedef struct {
 195   SWIG_CSharpExceptionCodes code;
 196   SWIG_CSharpExceptionCallback_t callback;
 197 } SWIG_CSharpException_t;
 198
 199 typedef struct {
 200   SWIG_CSharpExceptionArgumentCodes code;
 201   SWIG_CSharpExceptionArgumentCallback_t callback;
 202 } SWIG_CSharpExceptionArgument_t;
 203
 204 SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
 205   { SWIG_CSharpApplicationException, NULL },
 206   { SWIG_CSharpArithmeticException, NULL },
 207   { SWIG_CSharpDivideByZeroException, NULL },
 208   { SWIG_CSharpIndexOutOfRangeException, NULL },
 209   { SWIG_CSharpInvalidCastException, NULL },
 210   { SWIG_CSharpInvalidOperationException, NULL },
 211   { SWIG_CSharpIOException, NULL },
 212   { SWIG_CSharpNullReferenceException, NULL },
 213   { SWIG_CSharpOutOfMemoryException, NULL },
 214   { SWIG_CSharpOverflowException, NULL },
 215   { SWIG_CSharpSystemException, NULL }
 216 };
 217
 218 SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
 219   { SWIG_CSharpArgumentException, NULL },
 220   { SWIG_CSharpArgumentNullException, NULL },
 221   { SWIG_CSharpArgumentOutOfRangeException, NULL }
 222 };
 223
 224 void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
 225   SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
 226   if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
 227     callback = SWIG_csharp_exceptions[code].callback;
 228   }
 229   callback(msg);
 230 }
 231
 232 void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
 233   SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
 234   if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
 235     callback = SWIG_csharp_exceptions_argument[code].callback;
 236   }
 237   callback(msg, param_name);
 238 }
 239
 240
 241 #ifdef __cplusplus
 242 extern "C"
 243 #endif
 244 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_NDalic(
 245                                                 SWIG_CSharpExceptionCallback_t applicationCallback,
 246                                                 SWIG_CSharpExceptionCallback_t arithmeticCallback,
 247                                                 SWIG_CSharpExceptionCallback_t divideByZeroCallback,
 248                                                 SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback,
 249                                                 SWIG_CSharpExceptionCallback_t invalidCastCallback,
 250                                                 SWIG_CSharpExceptionCallback_t invalidOperationCallback,
 251                                                 SWIG_CSharpExceptionCallback_t ioCallback,
 252                                                 SWIG_CSharpExceptionCallback_t nullReferenceCallback,
 253                                                 SWIG_CSharpExceptionCallback_t outOfMemoryCallback,
 254                                                 SWIG_CSharpExceptionCallback_t overflowCallback,
 255                                                 SWIG_CSharpExceptionCallback_t systemCallback) {
 256   SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
 257   SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
 258   SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
 259   SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
 260   SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
 261   SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
 262   SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
 263   SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
 264   SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
 265   SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
 266   SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
 267 }
 268
 269 #ifdef __cplusplus
 270 extern "C"
 271 #endif
 272 SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_NDalic(
 273                                                 SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
 274                                                 SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
 275                                                 SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
 276   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
 277   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
 278   SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
 279 }
 280
 281
 282 /* Callback for returning strings to C# without leaking memory */
 283 typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
 284 SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;
 285
 286 // keep argWidgetCs and argWidgetV so they're always available to DALi
 287 int argWidgetC = 1;
 288 char **argWidgetV = NULL;
 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 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
 426 #include <dali/devel-api/actors/actor-devel.h>
 427 #include <dali/devel-api/common/stage-devel.h>
 428 #include <dali/devel-api/events/key-event-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/environment-variable.h>
 440
 441 #include <dali-toolkit/devel-api/builder/builder.h>
 442
 443 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 444 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 445
 446 #include <dali-toolkit/devel-api/controls/control-devel.h>
 447 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 448 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 449 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 450 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 453 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 454
 455 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 456 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 457 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 458
 459 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 460 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 461 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 462
 463 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 464 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 465 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 466
 467 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 468
 469 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 470 #include <dali/devel-api/adaptor-framework/image-loading.h>
 471
 472 #include <dali/public-api/events/mouse-button.h>
 473
 474 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 475 #include "web-view-signal-converter.h"
 476
 477 #include <dali/integration-api/debug.h>
 478
 479 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 480
 481 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 482
 483
 484 // add here SWIG version check
 485
 486 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 487 // disable Swig-dependent warnings
 488
 489 // 'identifier1' has C-linkage specified,
 490 // but returns UDT 'identifier2' which is incompatible with C
 491 #pragma warning(disable: 4190)
 492
 493 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 494 #pragma warning(disable: 4800)
 495
 496 // debug info too long etc etc
 497 #pragma warning(disable: 4786)
 498 #endif
 499
 500
 501 #include <stdexcept>
 502
 503
 504 #include <string>
 505
 506
 507 #include <vector>
 508 #include <algorithm>
 509 #include <stdexcept>
 510
 511
 512 #include <map>
 513 #include <algorithm>
 514 #include <stdexcept>
 515
 516
 517 #include <utility>
 518
 519
 520 typedef float floatp;
 521
 522 SWIGINTERN floatp *new_floatp(){
 523   return new float();
 524 }
 525 SWIGINTERN void delete_floatp(floatp *self){
 526   if (self) delete self;
 527 }
 528 SWIGINTERN void floatp_assign(floatp *self,float value){
 529   *self = value;
 530 }
 531 SWIGINTERN float floatp_value(floatp *self){
 532   return *self;
 533 }
 534 SWIGINTERN float *floatp_cast(floatp *self){
 535   return self;
 536 }
 537 SWIGINTERN floatp *floatp_frompointer(float *t){
 538   return (floatp *) t;
 539 }
 540
 541 typedef int intp;
 542
 543 SWIGINTERN intp *new_intp(){
 544   return new int();
 545 }
 546 SWIGINTERN void delete_intp(intp *self){
 547   if (self) delete self;
 548 }
 549 SWIGINTERN void intp_assign(intp *self,int value){
 550   *self = value;
 551 }
 552 SWIGINTERN int intp_value(intp *self){
 553   return *self;
 554 }
 555 SWIGINTERN int *intp_cast(intp *self){
 556   return self;
 557 }
 558 SWIGINTERN intp *intp_frompointer(int *t){
 559   return (intp *) t;
 560 }
 561
 562 typedef double doublep;
 563
 564 SWIGINTERN doublep *new_doublep(){
 565   return new double();
 566 }
 567 SWIGINTERN void delete_doublep(doublep *self){
 568   if (self) delete self;
 569 }
 570 SWIGINTERN void doublep_assign(doublep *self,double value){
 571   *self = value;
 572 }
 573 SWIGINTERN double doublep_value(doublep *self){
 574   return *self;
 575 }
 576 SWIGINTERN double *doublep_cast(doublep *self){
 577   return self;
 578 }
 579 SWIGINTERN doublep *doublep_frompointer(double *t){
 580   return (doublep *) t;
 581 }
 582
 583 typedef unsigned int uintp;
 584
 585 SWIGINTERN uintp *new_uintp(){
 586   return new unsigned int();
 587 }
 588 SWIGINTERN void delete_uintp(uintp *self){
 589   if (self) delete self;
 590 }
 591 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 592   *self = value;
 593 }
 594 SWIGINTERN unsigned int uintp_value(uintp *self){
 595   return *self;
 596 }
 597 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 598   return self;
 599 }
 600 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 601   return (uintp *) t;
 602 }
 603
 604 typedef unsigned short ushortp;
 605
 606 SWIGINTERN ushortp *new_ushortp(){
 607   return new unsigned short();
 608 }
 609 SWIGINTERN void delete_ushortp(ushortp *self){
 610   if (self) delete self;
 611 }
 612 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 613   *self = value;
 614 }
 615 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 616   return *self;
 617 }
 618 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 619   return self;
 620 }
 621 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 622   return (ushortp *) t;
 623 }
 624
 625 unsigned int int_to_uint(int x) {
 626    return (unsigned int) x;
 627 }
 628
 629
 630 using namespace Dali;
 631 using namespace Dali::Toolkit;
 632
 633 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 634 {
 635   bool result = false;
 636   try
 637   {
 638     // C++ code. DALi uses Handle <-> Body design pattern.
 639     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 640     // Handles in DALi can be converted into a boolean type
 641     // to check if the handle has a valid body attached to it.
 642     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 643     if( *self )
 644     {
 645       result = true;
 646     }
 647     else
 648     {
 649       result = false;
 650     }
 651   }
 652   catch (std::out_of_range& e)
 653   {
 654     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 655     return 0;
 656   }
 657   catch (std::exception& e)
 658   {
 659     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 660     return 0;
 661   }
 662   catch (DaliException e)
 663   {
 664     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 665     return 0;
 666   }
 667   catch (...)
 668   {
 669     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 670     return 0;
 671   }
 672   return result;
 673 }
 674
 675 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 676 {
 677   bool result = false;
 678   try
 679   {
 680     // C++ code. Check if two handles reference the same implemtion
 681     if( *self == rhs)
 682     {
 683       result = true;
 684     }
 685     else
 686     {
 687       result = false;
 688     }
 689   }
 690   catch (std::out_of_range& e)
 691   {
 692     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 693     return 0;
 694   }
 695   catch (std::exception& e)
 696   {
 697     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 698     return 0;
 699   }
 700   catch (DaliException e)
 701   {
 702     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 703     return 0;
 704   }
 705   catch (...)
 706   {
 707     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 708     return 0;
 709   }
 710   return result;
 711 }
 712
 713
 714 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 715      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 716    }
 717 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){
 718      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 719    }
 720 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 721         std::vector< Dali::TouchPoint >* pv = 0;
 722         if (capacity >= 0) {
 723           pv = new std::vector< Dali::TouchPoint >();
 724           pv->reserve(capacity);
 725        } else {
 726           throw std::out_of_range("capacity");
 727        }
 728        return pv;
 729       }
 730 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(std::vector< Dali::TouchPoint > *self,int index){
 731         if (index>=0 && index<(int)self->size())
 732           return (*self)[index];
 733         else
 734           throw std::out_of_range("index");
 735       }
 736 SWIGINTERN Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 737         if (index>=0 && index<(int)self->size())
 738           return (*self)[index];
 739         else
 740           throw std::out_of_range("index");
 741       }
 742 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 743         if (index>=0 && index<(int)self->size())
 744           (*self)[index] = val;
 745         else
 746           throw std::out_of_range("index");
 747       }
 748 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 749         self->insert(self->end(), values.begin(), values.end());
 750       }
 751 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 752         if (index < 0)
 753           throw std::out_of_range("index");
 754         if (count < 0)
 755           throw std::out_of_range("count");
 756         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 757           throw std::invalid_argument("invalid range");
 758         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 759       }
 760 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 761         if (index>=0 && index<(int)self->size()+1)
 762           self->insert(self->begin()+index, x);
 763         else
 764           throw std::out_of_range("index");
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 767         if (index>=0 && index<(int)self->size()+1)
 768           self->insert(self->begin()+index, values.begin(), values.end());
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 773         if (index>=0 && index<(int)self->size())
 774           self->erase(self->begin() + index);
 775         else
 776           throw std::out_of_range("index");
 777       }
 778 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 779         if (index < 0)
 780           throw std::out_of_range("index");
 781         if (count < 0)
 782           throw std::out_of_range("count");
 783         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 784           throw std::invalid_argument("invalid range");
 785         self->erase(self->begin()+index, self->begin()+index+count);
 786       }
 787 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 788         if (count < 0)
 789           throw std::out_of_range("count");
 790         return new std::vector< Dali::TouchPoint >(count, value);
 791       }
 792 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 793         std::reverse(self->begin(), self->end());
 794       }
 795 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 796         if (index < 0)
 797           throw std::out_of_range("index");
 798         if (count < 0)
 799           throw std::out_of_range("count");
 800         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 801           throw std::invalid_argument("invalid range");
 802         std::reverse(self->begin()+index, self->begin()+index+count);
 803       }
 804 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 805         if (index < 0)
 806           throw std::out_of_range("index");
 807         if (index+values.size() > self->size())
 808           throw std::out_of_range("index");
 809         std::copy(values.begin(), values.end(), self->begin()+index);
 810       }
 811 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 812          return self->Empty();
 813       }
 814 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 815         return self->GetConnectionCount();
 816       }
 817 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 818           self->Connect( func );
 819       }
 820 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 821           self->Disconnect( func );
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 824           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 825 /*@SWIG@*/ self->Emit( arg );
 826       }
 827 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 828          return self->Empty();
 829       }
 830 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 831         return self->GetConnectionCount();
 832       }
 833 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 834           self->Connect( func );
 835       }
 836 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 837           self->Disconnect( func );
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 840           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 841 /*@SWIG@*/ self->Emit( arg );
 842       }
 843 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 844          return self->Empty();
 845       }
 846 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){
 847         return self->GetConnectionCount();
 848       }
 849 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 *)){
 850           self->Connect( func );
 851       }
 852 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 *)){
 853           self->Disconnect( func );
 854       }
 855 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){
 856           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 857 /*@SWIG@*/ self->Emit( arg );
 858       }
 859 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 860          return self->Empty();
 861       }
 862 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 863         return self->GetConnectionCount();
 864       }
 865 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 866           self->Connect( func );
 867       }
 868 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 869           self->Disconnect( func );
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 872           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 873 /*@SWIG@*/ self->Emit( arg );
 874       }
 875 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty(Dali::Signal< void (Dali::Image) > const *self){
 876          return self->Empty();
 877       }
 878 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Image) > const *self){
 879         return self->GetConnectionCount();
 880       }
 881 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 882           self->Connect( func );
 883       }
 884 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(Dali::Signal< void (Dali::Image) > *self,void (*func)(Dali::Image)){
 885           self->Disconnect( func );
 886       }
 887 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(Dali::Signal< void (Dali::Image) > *self,Dali::Image arg){
 888           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 889 /*@SWIG@*/ self->Emit( arg );
 890       }
 891 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){
 892          return self->Empty();
 893       }
 894 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){
 895         return self->GetConnectionCount();
 896       }
 897 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 &)){
 898         self->Connect( func );
 899       }
 900 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 &)){
 901         self->Disconnect( func );
 902       }
 903 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){
 904         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 905 /*@SWIG@*/ self->Emit( arg1, arg2 );
 906       }
 907 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){
 908          return self->Empty();
 909       }
 910 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){
 911         return self->GetConnectionCount();
 912       }
 913 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 &)){
 914         self->Connect( func );
 915       }
 916 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 &)){
 917         self->Disconnect( func );
 918       }
 919 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){
 920         return self->Emit( arg1, arg2 );
 921       }
 922 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){
 923          return self->Empty();
 924       }
 925 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){
 926         return self->GetConnectionCount();
 927       }
 928 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 &)){
 929         self->Connect( func );
 930       }
 931 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 &)){
 932         self->Disconnect( func );
 933       }
 934 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){
 935         return self->Emit( arg1, arg2 );
 936       }
 937 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){
 938          return self->Empty();
 939       }
 940 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){
 941         return self->GetConnectionCount();
 942       }
 943 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 &)){
 944         self->Connect( func );
 945       }
 946 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 &)){
 947         self->Disconnect( func );
 948       }
 949 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){
 950         return self->Emit( arg1, arg2 );
 951       }
 952 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 953          return self->Empty();
 954       }
 955 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 956         return self->GetConnectionCount();
 957       }
 958 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 959           self->Connect( func );
 960       }
 961 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 962           self->Disconnect( func );
 963       }
 964 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 965           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 966 /*@SWIG@*/ self->Emit( arg );
 967       }
 968 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 969          return self->Empty();
 970       }
 971 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){
 972         return self->GetConnectionCount();
 973       }
 974 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 &)){
 975           self->Connect( func );
 976       }
 977 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 &)){
 978           self->Disconnect( func );
 979       }
 980 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){
 981           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 982 /*@SWIG@*/ self->Emit( arg );
 983       }
 984 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 985          return self->Empty();
 986       }
 987 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){
 988         return self->GetConnectionCount();
 989       }
 990 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 &)){
 991           self->Connect( func );
 992       }
 993 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 &)){
 994           self->Disconnect( func );
 995       }
 996 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){
 997           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 998 /*@SWIG@*/ self->Emit( arg );
 999       }
1000 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
1001          return self->Empty();
1002       }
1003 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){
1004         return self->GetConnectionCount();
1005       }
1006 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 &)){
1007           self->Connect( func );
1008       }
1009 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 &)){
1010           self->Disconnect( func );
1011       }
1012 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){
1013           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1014 /*@SWIG@*/ self->Emit( arg );
1015       }
1016 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){
1017          return self->Empty();
1018       }
1019 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){
1020         return self->GetConnectionCount();
1021       }
1022 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 &)){
1023         self->Connect( func );
1024       }
1025 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 &)){
1026         self->Disconnect( func );
1027       }
1028 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){
1029         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1030 /*@SWIG@*/ self->Emit( arg1, arg2 );
1031       }
1032 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){
1033          return self->Empty();
1034       }
1035 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){
1036         return self->GetConnectionCount();
1037       }
1038 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 &)){
1039         self->Connect( func );
1040       }
1041 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 &)){
1042         self->Disconnect( func );
1043       }
1044 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){
1045         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1046 /*@SWIG@*/ self->Emit( arg1, arg2 );
1047       }
1048 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){
1049          return self->Empty();
1050       }
1051 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){
1052         return self->GetConnectionCount();
1053       }
1054 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 &)){
1055         self->Connect( func );
1056       }
1057 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 &)){
1058         self->Disconnect( func );
1059       }
1060 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){
1061         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1062 /*@SWIG@*/ self->Emit( arg1, arg2 );
1063       }
1064 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty(Dali::Signal< void (Dali::ResourceImage) > const *self){
1065          return self->Empty();
1066       }
1067 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::ResourceImage) > const *self){
1068         return self->GetConnectionCount();
1069       }
1070 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1071           self->Connect( func );
1072       }
1073 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(Dali::Signal< void (Dali::ResourceImage) > *self,void (*func)(Dali::ResourceImage)){
1074           self->Disconnect( func );
1075       }
1076 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(Dali::Signal< void (Dali::ResourceImage) > *self,Dali::ResourceImage arg){
1077           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1078 /*@SWIG@*/ self->Emit( arg );
1079       }
1080 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1081          return self->Empty();
1082       }
1083 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *self){
1084         return self->GetConnectionCount();
1085       }
1086 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1087           return self->Connect( func );
1088       }
1089 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,void (*func)(Dali::Actor, Dali::LayoutDirection::Type)){
1090           self->Disconnect( func );
1091       }
1092 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *self,Dali::Actor arg1, Dali::LayoutDirection::Type arg3){
1093           self->Emit( arg1, arg3 );
1094       }
1095 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){
1096          return self->Empty();
1097       }
1098 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){
1099         return self->GetConnectionCount();
1100       }
1101 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)){
1102           return self->Connect( func );
1103       }
1104 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)){
1105           self->Disconnect( func );
1106       }
1107 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){
1108           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1109 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1110       }
1111
1112 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1113          return self->Empty();
1114       }
1115 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1116         return self->GetConnectionCount();
1117       }
1118 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1119           self->Connect( func );
1120       }
1121 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1122           self->Disconnect( func );
1123       }
1124 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1125           return self->Emit();
1126       }
1127
1128 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1129         std::vector< unsigned int >* pv = 0;
1130         if (capacity >= 0) {
1131           pv = new std::vector< unsigned int >();
1132           pv->reserve(capacity);
1133        } else {
1134           throw std::out_of_range("capacity");
1135        }
1136        return pv;
1137       }
1138 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1139         if (index>=0 && index<(int)self->size())
1140           return (*self)[index];
1141         else
1142           throw std::out_of_range("index");
1143       }
1144 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1145         if (index>=0 && index<(int)self->size())
1146           return (*self)[index];
1147         else
1148           throw std::out_of_range("index");
1149       }
1150 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1151         if (index>=0 && index<(int)self->size())
1152           (*self)[index] = val;
1153         else
1154           throw std::out_of_range("index");
1155       }
1156 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1157         self->insert(self->end(), values.begin(), values.end());
1158       }
1159 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1160         if (index < 0)
1161           throw std::out_of_range("index");
1162         if (count < 0)
1163           throw std::out_of_range("count");
1164         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1165           throw std::invalid_argument("invalid range");
1166         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1167       }
1168 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1169         if (index>=0 && index<(int)self->size()+1)
1170           self->insert(self->begin()+index, x);
1171         else
1172           throw std::out_of_range("index");
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1175         if (index>=0 && index<(int)self->size()+1)
1176           self->insert(self->begin()+index, values.begin(), values.end());
1177         else
1178           throw std::out_of_range("index");
1179       }
1180 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1181         if (index>=0 && index<(int)self->size())
1182           self->erase(self->begin() + index);
1183         else
1184           throw std::out_of_range("index");
1185       }
1186 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1187         if (index < 0)
1188           throw std::out_of_range("index");
1189         if (count < 0)
1190           throw std::out_of_range("count");
1191         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1192           throw std::invalid_argument("invalid range");
1193         self->erase(self->begin()+index, self->begin()+index+count);
1194       }
1195 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1196         if (count < 0)
1197           throw std::out_of_range("count");
1198         return new std::vector< unsigned int >(count, value);
1199       }
1200 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1201         std::reverse(self->begin(), self->end());
1202       }
1203 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1204         if (index < 0)
1205           throw std::out_of_range("index");
1206         if (count < 0)
1207           throw std::out_of_range("count");
1208         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1209           throw std::invalid_argument("invalid range");
1210         std::reverse(self->begin()+index, self->begin()+index+count);
1211       }
1212 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1213         if (index < 0)
1214           throw std::out_of_range("index");
1215         if (index+values.size() > self->size())
1216           throw std::out_of_range("index");
1217         std::copy(values.begin(), values.end(), self->begin()+index);
1218       }
1219 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1220         return std::find(self->begin(), self->end(), value) != self->end();
1221       }
1222 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1223         int index = -1;
1224         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1225         if (it != self->end())
1226           index = (int)(it - self->begin());
1227         return index;
1228       }
1229 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1230         int index = -1;
1231         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1232         if (rit != self->rend())
1233           index = (int)(self->rend() - 1 - rit);
1234         return index;
1235       }
1236 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1237         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1238         if (it != self->end()) {
1239           self->erase(it);
1240           return true;
1241         }
1242         return false;
1243       }
1244 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){
1245         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1246         if (capacity >= 0) {
1247           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1248           pv->reserve(capacity);
1249        } else {
1250           throw std::out_of_range("capacity");
1251        }
1252        return pv;
1253       }
1254 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){
1255         if (index>=0 && index<(int)self->size())
1256           return (*self)[index];
1257         else
1258           throw std::out_of_range("index");
1259       }
1260 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){
1261         if (index>=0 && index<(int)self->size())
1262           return (*self)[index];
1263         else
1264           throw std::out_of_range("index");
1265       }
1266 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){
1267         if (index>=0 && index<(int)self->size())
1268           (*self)[index] = val;
1269         else
1270           throw std::out_of_range("index");
1271       }
1272 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){
1273         self->insert(self->end(), values.begin(), values.end());
1274       }
1275 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){
1276         if (index < 0)
1277           throw std::out_of_range("index");
1278         if (count < 0)
1279           throw std::out_of_range("count");
1280         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1281           throw std::invalid_argument("invalid range");
1282         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1283       }
1284 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){
1285         if (index>=0 && index<(int)self->size()+1)
1286           self->insert(self->begin()+index, x);
1287         else
1288           throw std::out_of_range("index");
1289       }
1290 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){
1291         if (index>=0 && index<(int)self->size()+1)
1292           self->insert(self->begin()+index, values.begin(), values.end());
1293         else
1294           throw std::out_of_range("index");
1295       }
1296 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){
1297         if (index>=0 && index<(int)self->size())
1298           self->erase(self->begin() + index);
1299         else
1300           throw std::out_of_range("index");
1301       }
1302 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){
1303         if (index < 0)
1304           throw std::out_of_range("index");
1305         if (count < 0)
1306           throw std::out_of_range("count");
1307         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1308           throw std::invalid_argument("invalid range");
1309         self->erase(self->begin()+index, self->begin()+index+count);
1310       }
1311 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){
1312         if (count < 0)
1313           throw std::out_of_range("count");
1314         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1315       }
1316 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){
1317         std::reverse(self->begin(), self->end());
1318       }
1319 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){
1320         if (index < 0)
1321           throw std::out_of_range("index");
1322         if (count < 0)
1323           throw std::out_of_range("count");
1324         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1325           throw std::invalid_argument("invalid range");
1326         std::reverse(self->begin()+index, self->begin()+index+count);
1327       }
1328 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){
1329         if (index < 0)
1330           throw std::out_of_range("index");
1331         if (index+values.size() > self->size())
1332           throw std::out_of_range("index");
1333         std::copy(values.begin(), values.end(), self->begin()+index);
1334       }
1335 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1336         std::vector< Dali::Actor >* pv = 0;
1337         if (capacity >= 0) {
1338           pv = new std::vector< Dali::Actor >();
1339           pv->reserve(capacity);
1340        } else {
1341           throw std::out_of_range("capacity");
1342        }
1343        return pv;
1344       }
1345 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1346         if (index>=0 && index<(int)self->size())
1347           return (*self)[index];
1348         else
1349           throw std::out_of_range("index");
1350       }
1351 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1352         if (index>=0 && index<(int)self->size())
1353           return (*self)[index];
1354         else
1355           throw std::out_of_range("index");
1356       }
1357 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1358         if (index>=0 && index<(int)self->size())
1359           (*self)[index] = val;
1360         else
1361           throw std::out_of_range("index");
1362       }
1363 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1364         self->insert(self->end(), values.begin(), values.end());
1365       }
1366 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1367         if (index < 0)
1368           throw std::out_of_range("index");
1369         if (count < 0)
1370           throw std::out_of_range("count");
1371         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1372           throw std::invalid_argument("invalid range");
1373         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1374       }
1375 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1376         if (index>=0 && index<(int)self->size()+1)
1377           self->insert(self->begin()+index, x);
1378         else
1379           throw std::out_of_range("index");
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1382         if (index>=0 && index<(int)self->size()+1)
1383           self->insert(self->begin()+index, values.begin(), values.end());
1384         else
1385           throw std::out_of_range("index");
1386       }
1387 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1388         if (index>=0 && index<(int)self->size())
1389           self->erase(self->begin() + index);
1390         else
1391           throw std::out_of_range("index");
1392       }
1393 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1394         if (index < 0)
1395           throw std::out_of_range("index");
1396         if (count < 0)
1397           throw std::out_of_range("count");
1398         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1399           throw std::invalid_argument("invalid range");
1400         self->erase(self->begin()+index, self->begin()+index+count);
1401       }
1402 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1403         if (count < 0)
1404           throw std::out_of_range("count");
1405         return new std::vector< Dali::Actor >(count, value);
1406       }
1407 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1408         std::reverse(self->begin(), self->end());
1409       }
1410 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1411         if (index < 0)
1412           throw std::out_of_range("index");
1413         if (count < 0)
1414           throw std::out_of_range("count");
1415         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1416           throw std::invalid_argument("invalid range");
1417         std::reverse(self->begin()+index, self->begin()+index+count);
1418       }
1419 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1420         if (index < 0)
1421           throw std::out_of_range("index");
1422         if (index+values.size() > self->size())
1423           throw std::out_of_range("index");
1424         std::copy(values.begin(), values.end(), self->begin()+index);
1425       }
1426 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1427          return self->Empty();
1428       }
1429 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1430         return self->GetConnectionCount();
1431       }
1432 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 &)){
1433           self->Connect( func );
1434       }
1435 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 &)){
1436           self->Disconnect( func );
1437       }
1438 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){
1439           return self->Emit( arg );
1440       }
1441 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){
1442          return self->Empty();
1443       }
1444 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){
1445         return self->GetConnectionCount();
1446       }
1447 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)){
1448         self->Connect( func );
1449       }
1450 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)){
1451         self->Disconnect( func );
1452       }
1453 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){
1454         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1455 /*@SWIG@*/ self->Emit( arg1, arg2 );
1456       }
1457 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1458          return self->Empty();
1459       }
1460 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){
1461         return self->GetConnectionCount();
1462       }
1463 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)){
1464         self->Connect( func );
1465       }
1466 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)){
1467         self->Disconnect( func );
1468       }
1469 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){
1470         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1471 /*@SWIG@*/ self->Emit( arg1, arg2 );
1472       }
1473 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1474          return self->Empty();
1475       }
1476 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1477         return self->GetConnectionCount();
1478       }
1479 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)){
1480         self->Connect( func );
1481       }
1482 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)){
1483         self->Disconnect( func );
1484       }
1485 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){
1486         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1487 /*@SWIG@*/ self->Emit( arg1, arg2 );
1488       }
1489 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){
1490          return self->Empty();
1491       }
1492 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){
1493         return self->GetConnectionCount();
1494       }
1495 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)){
1496         self->Connect( func );
1497       }
1498 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)){
1499         self->Disconnect( func );
1500       }
1501 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){
1502         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1503 /*@SWIG@*/ self->Emit( arg1, arg2 );
1504       }
1505 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1506          return self->Empty();
1507       }
1508 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1509         return self->GetConnectionCount();
1510       }
1511 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)){
1512           self->Connect( func );
1513       }
1514 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)){
1515           self->Disconnect( func );
1516       }
1517 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1518           return self->Emit( arg );
1519       }
1520 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1521          return self->Empty();
1522       }
1523 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1524         return self->GetConnectionCount();
1525       }
1526 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)){
1527           self->Connect( func );
1528       }
1529 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)){
1530           self->Disconnect( func );
1531       }
1532 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1533           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1534 /*@SWIG@*/ self->Emit( arg );
1535       }
1536 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){
1537          return self->Empty();
1538       }
1539 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){
1540         return self->GetConnectionCount();
1541       }
1542 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)){
1543           return self->Connect( func );
1544       }
1545 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)){
1546           self->Disconnect( func );
1547       }
1548 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){
1549           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1550 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1551       }
1552 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1553          return self->Empty();
1554       }
1555 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1556         return self->GetConnectionCount();
1557       }
1558 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)){
1559           self->Connect( func );
1560       }
1561 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)){
1562           self->Disconnect( func );
1563       }
1564 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1565           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1566 /*@SWIG@*/ self->Emit( arg );
1567       }
1568 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){
1569          return self->Empty();
1570       }
1571 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){
1572         return self->GetConnectionCount();
1573       }
1574 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)){
1575           return self->Connect( func );
1576       }
1577 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)){
1578           self->Disconnect( func );
1579       }
1580 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){
1581           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1582 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1583       }
1584 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){
1585          return self->Empty();
1586       }
1587 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){
1588         return self->GetConnectionCount();
1589       }
1590 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 &)){
1591           self->Connect( func );
1592       }
1593 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 &)){
1594           self->Disconnect( func );
1595       }
1596 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){
1597           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1598 /*@SWIG@*/ self->Emit( arg );
1599       }
1600 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1601          return self->Empty();
1602       }
1603 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){
1604         return self->GetConnectionCount();
1605       }
1606 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 &)){
1607           self->Connect( func );
1608       }
1609 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 &)){
1610           self->Disconnect( func );
1611       }
1612 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){
1613           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1614 /*@SWIG@*/ self->Emit( arg );
1615       }
1616
1617
1618 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){
1619          return self->Empty();
1620       }
1621 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){
1622         return self->GetConnectionCount();
1623       }
1624 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 &)){
1625         self->Connect( func );
1626       }
1627 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 &)){
1628         self->Disconnect( func );
1629       }
1630 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){
1631         return self->Emit( arg1, arg2 );
1632       }
1633 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1634          return self->Empty();
1635       }
1636 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1637         return self->GetConnectionCount();
1638       }
1639 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)){
1640           self->Connect( func );
1641       }
1642 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)){
1643           self->Disconnect( func );
1644       }
1645 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1646           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1647 /*@SWIG@*/ self->Emit( arg );
1648       }
1649 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1650          return self->Empty();
1651       }
1652 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1653         return self->GetConnectionCount();
1654       }
1655 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 &)){
1656           self->Connect( func );
1657       }
1658 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 &)){
1659           self->Disconnect( func );
1660       }
1661 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){
1662           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1663 /*@SWIG@*/ self->Emit( arg );
1664       }
1665 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1666          return self->Empty();
1667       }
1668 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){
1669         return self->GetConnectionCount();
1670       }
1671 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)){
1672         self->Connect( func );
1673       }
1674 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)){
1675         self->Disconnect( func );
1676       }
1677 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){
1678         return self->Emit( arg1, arg2 );
1679       }
1680 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1681          return self->Empty();
1682       }
1683 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){
1684         return self->GetConnectionCount();
1685       }
1686 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)){
1687         self->Connect( func );
1688       }
1689 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)){
1690         self->Disconnect( func );
1691       }
1692 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){
1693         return self->Emit( arg1, arg2 );
1694       }
1695
1696 /* ---------------------------------------------------
1697  * C++ director class methods
1698  * --------------------------------------------------- */
1699
1700 #include "dali_wrap.h"
1701
1702 /*
1703  *  Widget director
1704  */
1705 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1706   swig_init_callbacks();
1707 }
1708
1709 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1710 }
1711
1712 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1713   char * jcontentInfo = 0 ;
1714   void * jwindow  ;
1715
1716   if (!swig_callbackOnCreate) {
1717     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1718     return;
1719   } else {
1720     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1721     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1722     swig_callbackOnCreate(jcontentInfo, jwindow);
1723   }
1724 }
1725
1726 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1727   char * jcontentInfo = 0 ;
1728   int jtype  ;
1729
1730   if (!swig_callbackOnTerminate) {
1731     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1732     return;
1733   } else {
1734     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1735     jtype = (int)type;
1736     swig_callbackOnTerminate(jcontentInfo, jtype);
1737   }
1738 }
1739
1740 void SwigDirector_WidgetImpl::OnPause() {
1741   if (!swig_callbackOnPause) {
1742     Dali::Internal::Adaptor::Widget::OnPause();
1743     return;
1744   } else {
1745     swig_callbackOnPause();
1746   }
1747 }
1748
1749 void SwigDirector_WidgetImpl::OnResume() {
1750   if (!swig_callbackOnResume) {
1751     Dali::Internal::Adaptor::Widget::OnResume();
1752     return;
1753   } else {
1754     swig_callbackOnResume();
1755   }
1756 }
1757
1758 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1759   void * jwindow  ;
1760
1761   if (!swig_callbackOnResize) {
1762     Dali::Internal::Adaptor::Widget::OnResize(window);
1763     return;
1764   } else {
1765     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1766     swig_callbackOnResize(jwindow);
1767   }
1768 }
1769
1770 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1771   char * jcontentInfo = 0 ;
1772   int jforce  ;
1773
1774   if (!swig_callbackOnUpdate) {
1775     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1776     return;
1777   } else {
1778     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1779     jforce = force;
1780     swig_callbackOnUpdate(jcontentInfo, jforce);
1781   }
1782 }
1783
1784 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1785   void * jslotObserver = 0 ;
1786   void * jcallback = 0 ;
1787
1788   if (!swig_callbackSignalConnected) {
1789     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1790     return;
1791   } else {
1792     jslotObserver = (void *) slotObserver;
1793     jcallback = (void *) callback;
1794     swig_callbackSignalConnected(jslotObserver, jcallback);
1795   }
1796 }
1797
1798 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1799   void * jslotObserver = 0 ;
1800   void * jcallback = 0 ;
1801
1802   if (!swig_callbackSignalDisconnected) {
1803     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1804     return;
1805   } else {
1806     jslotObserver = (void *) slotObserver;
1807     jcallback = (void *) callback;
1808     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1809   }
1810 }
1811
1812 void SwigDirector_WidgetImpl::swig_connect_director(SWIG_Callback0_t callbackOnCreate, SWIG_Callback1_t callbackOnTerminate, SWIG_Callback2_t callbackOnPause, SWIG_Callback3_t callbackOnResume, SWIG_Callback4_t callbackOnResize, SWIG_Callback5_t callbackOnUpdate, SWIG_Callback6_t callbackSignalConnected, SWIG_Callback7_t callbackSignalDisconnected) {
1813
1814   swig_callbackOnCreate = callbackOnCreate;
1815   swig_callbackOnTerminate = callbackOnTerminate;
1816   swig_callbackOnPause = callbackOnPause;
1817   swig_callbackOnResume = callbackOnResume;
1818   swig_callbackOnResize = callbackOnResize;
1819   swig_callbackOnUpdate = callbackOnUpdate;
1820   swig_callbackSignalConnected = callbackSignalConnected;
1821   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1822 }
1823
1824 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1825   swig_callbackOnCreate = 0;
1826   swig_callbackOnTerminate = 0;
1827   swig_callbackOnPause = 0;
1828   swig_callbackOnResume = 0;
1829   swig_callbackOnResize = 0;
1830   swig_callbackOnUpdate = 0;
1831   swig_callbackSignalConnected = 0;
1832   swig_callbackSignalDisconnected = 0;
1833 }
1834
1835
1836 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1837   swig_init_callbacks();
1838 }
1839
1840 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1841
1842 }
1843
1844
1845 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1846   int jdepth  ;
1847
1848   if (!swig_callbackOnStageConnection) {
1849     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1850     return;
1851   } else {
1852     jdepth = depth;
1853     swig_callbackOnStageConnection(jdepth);
1854   }
1855 }
1856
1857 void SwigDirector_ViewImpl::OnStageDisconnection() {
1858   if (!swig_callbackOnStageDisconnection) {
1859     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1860     return;
1861   } else {
1862     swig_callbackOnStageDisconnection();
1863   }
1864 }
1865
1866 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1867   void * jchild = 0 ;
1868
1869   if (!swig_callbackOnChildAdd) {
1870     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1871     return;
1872   } else {
1873     jchild = (Dali::Actor *) &child;
1874     swig_callbackOnChildAdd(jchild);
1875   }
1876 }
1877
1878 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1879   void * jchild = 0 ;
1880
1881   if (!swig_callbackOnChildRemove) {
1882     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1883     return;
1884   } else {
1885     jchild = (Dali::Actor *) &child;
1886     swig_callbackOnChildRemove(jchild);
1887   }
1888 }
1889
1890 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1891   int jindex  ;
1892   void * jpropertyValue  ;
1893
1894   if (!swig_callbackOnPropertySet) {
1895     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1896     return;
1897   } else {
1898     jindex = index;
1899     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1900     swig_callbackOnPropertySet(jindex, jpropertyValue);
1901   }
1902 }
1903
1904 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1905   void * jtargetSize = 0 ;
1906
1907   if (!swig_callbackOnSizeSet) {
1908     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1909     return;
1910   } else {
1911     jtargetSize = (Dali::Vector3 *) &targetSize;
1912     swig_callbackOnSizeSet(jtargetSize);
1913   }
1914 }
1915
1916 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1917   void * janimation = 0 ;
1918   void * jtargetSize = 0 ;
1919
1920   if (!swig_callbackOnSizeAnimation) {
1921     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1922     return;
1923   } else {
1924     janimation = (Dali::Animation *) &animation;
1925     jtargetSize = (Dali::Vector3 *) &targetSize;
1926     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1927   }
1928 }
1929
1930 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1931   bool c_result = SwigValueInit< bool >() ;
1932   unsigned int jresult = 0 ;
1933   void * jarg0 = 0 ;
1934
1935   if (!swig_callbackOnTouchEvent) {
1936     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1937   } else {
1938     jarg0 = (Dali::TouchEvent *) &event;
1939     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1940     c_result = jresult ? true : false;
1941   }
1942   return c_result;
1943 }
1944
1945 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1946   bool c_result = SwigValueInit< bool >() ;
1947   unsigned int jresult = 0 ;
1948   void * jarg0 = 0 ;
1949
1950   if (!swig_callbackOnHoverEvent) {
1951     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1952   } else {
1953     jarg0 = (Dali::HoverEvent *) &event;
1954     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1955     c_result = jresult ? true : false;
1956   }
1957   return c_result;
1958 }
1959
1960 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1961   bool c_result = SwigValueInit< bool >() ;
1962   unsigned int jresult = 0 ;
1963   void * jarg0 = 0 ;
1964
1965   if (!swig_callbackOnKeyEvent) {
1966     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1967   } else {
1968     jarg0 = (Dali::KeyEvent *) &event;
1969     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1970     c_result = jresult ? true : false;
1971   }
1972   return c_result;
1973 }
1974
1975 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1976   bool c_result = SwigValueInit< bool >() ;
1977   unsigned int jresult = 0 ;
1978   void * jarg0 = 0 ;
1979
1980   if (!swig_callbackOnWheelEvent) {
1981     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1982   } else {
1983     jarg0 = (Dali::WheelEvent *) &event;
1984     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1985     c_result = jresult ? true : false;
1986   }
1987   return c_result;
1988 }
1989
1990 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1991   void * jsize = 0 ;
1992   void * jcontainer = 0 ;
1993
1994   if (!swig_callbackOnRelayout) {
1995     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1996     return;
1997   } else {
1998     jsize = (Dali::Vector2 *) &size;
1999     jcontainer = (Dali::RelayoutContainer *) &container;
2000     swig_callbackOnRelayout(jsize, jcontainer);
2001   }
2002 }
2003
2004 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
2005   int jpolicy  ;
2006   int jdimension  ;
2007
2008   if (!swig_callbackOnSetResizePolicy) {
2009     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
2010     return;
2011   } else {
2012     jpolicy = (int)policy;
2013     jdimension = (int)dimension;
2014     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
2015   }
2016 }
2017
2018 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
2019   Dali::Vector3 c_result ;
2020   void * jresult = 0 ;
2021
2022   if (!swig_callbackGetNaturalSize) {
2023     return Dali::Toolkit::Internal::Control::GetNaturalSize();
2024   } else {
2025     jresult = (void *) swig_callbackGetNaturalSize();
2026     if (!jresult) {
2027       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2028       return c_result;
2029     }
2030     c_result = *(Dali::Vector3 *)jresult;
2031   }
2032   return c_result;
2033 }
2034
2035 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2036   float c_result = SwigValueInit< float >() ;
2037   float jresult = 0 ;
2038   void * jchild = 0 ;
2039   int jdimension  ;
2040
2041   if (!swig_callbackCalculateChildSize) {
2042     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2043   } else {
2044     jchild = (Dali::Actor *) &child;
2045     jdimension = (int)dimension;
2046     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2047     c_result = (float)jresult;
2048   }
2049   return c_result;
2050 }
2051
2052 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2053   float c_result = SwigValueInit< float >() ;
2054   float jresult = 0 ;
2055   float jwidth  ;
2056
2057   if (!swig_callbackGetHeightForWidth) {
2058     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2059   } else {
2060     jwidth = width;
2061     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2062     c_result = (float)jresult;
2063   }
2064   return c_result;
2065 }
2066
2067 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2068   float c_result = SwigValueInit< float >() ;
2069   float jresult = 0 ;
2070   float jheight  ;
2071
2072   if (!swig_callbackGetWidthForHeight) {
2073     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2074   } else {
2075     jheight = height;
2076     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2077     c_result = (float)jresult;
2078   }
2079   return c_result;
2080 }
2081
2082 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2083   bool c_result = SwigValueInit< bool >() ;
2084   unsigned int jresult = 0 ;
2085   int jdimension  ;
2086
2087   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2088     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2089   } else {
2090     jdimension = (int)dimension;
2091     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2092     c_result = jresult ? true : false;
2093   }
2094   return c_result;
2095 }
2096
2097 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2098   int jdimension  ;
2099
2100   if (!swig_callbackOnCalculateRelayoutSize) {
2101     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2102     return;
2103   } else {
2104     jdimension = (int)dimension;
2105     swig_callbackOnCalculateRelayoutSize(jdimension);
2106   }
2107 }
2108
2109 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2110   float jsize  ;
2111   int jdimension  ;
2112
2113   if (!swig_callbackOnLayoutNegotiated) {
2114     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2115     return;
2116   } else {
2117     jsize = size;
2118     jdimension = (int)dimension;
2119     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2120   }
2121 }
2122
2123 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2124   return Dali::CustomActorImpl::GetExtension();
2125 }
2126
2127 void SwigDirector_ViewImpl::OnInitialize() {
2128   if (!swig_callbackOnInitialize) {
2129     Dali::Toolkit::Internal::Control::OnInitialize();
2130     return;
2131   } else {
2132     swig_callbackOnInitialize();
2133   }
2134 }
2135
2136 void SwigDirector_ViewImpl::OnControlChildAdd(Dali::Actor &child) {
2137   void * jchild = 0 ;
2138
2139   if (!swig_callbackOnControlChildAdd) {
2140     Dali::Toolkit::Internal::Control::OnControlChildAdd(child);
2141     return;
2142   } else {
2143     jchild = (Dali::Actor *) &child;
2144     swig_callbackOnControlChildAdd(jchild);
2145   }
2146 }
2147
2148 void SwigDirector_ViewImpl::OnControlChildRemove(Dali::Actor &child) {
2149   void * jchild = 0 ;
2150
2151   if (!swig_callbackOnControlChildRemove) {
2152     Dali::Toolkit::Internal::Control::OnControlChildRemove(child);
2153     return;
2154   } else {
2155     jchild = (Dali::Actor *) &child;
2156     swig_callbackOnControlChildRemove(jchild);
2157   }
2158 }
2159
2160 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2161   void * jstyleManager  ;
2162   int jchange  ;
2163
2164   if (!swig_callbackOnStyleChange) {
2165     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2166     return;
2167   } else {
2168     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2169     jchange = (int)change;
2170     swig_callbackOnStyleChange(jstyleManager, jchange);
2171   }
2172 }
2173
2174 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2175   bool c_result = SwigValueInit< bool >() ;
2176   unsigned int jresult = 0 ;
2177
2178   if (!swig_callbackOnAccessibilityActivated) {
2179     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2180   } else {
2181     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2182     c_result = jresult ? true : false;
2183   }
2184   return c_result;
2185 }
2186
2187 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2188   bool c_result = SwigValueInit< bool >() ;
2189   unsigned int jresult = 0 ;
2190   void * jgesture  ;
2191
2192   if (!swig_callbackOnAccessibilityPan) {
2193     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2194   } else {
2195     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2196     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2197     c_result = jresult ? true : false;
2198   }
2199   return c_result;
2200 }
2201
2202 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2203   bool c_result = SwigValueInit< bool >() ;
2204   unsigned int jresult = 0 ;
2205   void * jtouchEvent = 0 ;
2206
2207   if (!swig_callbackOnAccessibilityTouch) {
2208     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2209   } else {
2210     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2211     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2212     c_result = jresult ? true : false;
2213   }
2214   return c_result;
2215 }
2216
2217 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2218   bool c_result = SwigValueInit< bool >() ;
2219   unsigned int jresult = 0 ;
2220   unsigned int jisIncrease  ;
2221
2222   if (!swig_callbackOnAccessibilityValueChange) {
2223     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2224   } else {
2225     jisIncrease = isIncrease;
2226     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2227     c_result = jresult ? true : false;
2228   }
2229   return c_result;
2230 }
2231
2232 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2233   bool c_result = SwigValueInit< bool >() ;
2234   unsigned int jresult = 0 ;
2235
2236   if (!swig_callbackOnAccessibilityZoom) {
2237     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2238   } else {
2239     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2240     c_result = jresult ? true : false;
2241   }
2242   return c_result;
2243 }
2244
2245 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2246   if (!swig_callbackOnKeyInputFocusGained) {
2247     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2248     return;
2249   } else {
2250     swig_callbackOnKeyInputFocusGained();
2251   }
2252 }
2253
2254 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2255   if (!swig_callbackOnKeyInputFocusLost) {
2256     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2257     return;
2258   } else {
2259     swig_callbackOnKeyInputFocusLost();
2260   }
2261 }
2262
2263 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2264   Dali::Actor c_result ;
2265   void * jresult = 0 ;
2266   void * jcurrentFocusedActor  ;
2267   int jdirection  ;
2268   unsigned int jloopEnabled  ;
2269
2270   if (!swig_callbackGetNextKeyboardFocusableActor) {
2271     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2272   } else {
2273     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2274     jdirection = (int)direction;
2275     jloopEnabled = loopEnabled;
2276     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2277     if (!jresult) {
2278       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2279       return c_result;
2280     }
2281     c_result = *(Dali::Actor *)jresult;
2282   }
2283   return c_result;
2284 }
2285
2286 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2287   void * jcommitedFocusableActor  ;
2288
2289   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2290     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2291     return;
2292   } else {
2293     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2294     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2295   }
2296 }
2297
2298 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2299   bool c_result = SwigValueInit< bool >() ;
2300   unsigned int jresult = 0 ;
2301
2302   if (!swig_callbackOnKeyboardEnter) {
2303     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2304   } else {
2305     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2306     c_result = jresult ? true : false;
2307   }
2308   return c_result;
2309 }
2310
2311 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2312   void * jpinch = 0 ;
2313
2314   if (!swig_callbackOnPinch) {
2315     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2316     return;
2317   } else {
2318     jpinch = (Dali::PinchGesture *) &pinch;
2319     swig_callbackOnPinch(jpinch);
2320   }
2321 }
2322
2323 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2324   void * jpan = 0 ;
2325
2326   if (!swig_callbackOnPan) {
2327     Dali::Toolkit::Internal::Control::OnPan(pan);
2328     return;
2329   } else {
2330     jpan = (Dali::PanGesture *) &pan;
2331     swig_callbackOnPan(jpan);
2332   }
2333 }
2334
2335 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2336   void * jtap = 0 ;
2337
2338   if (!swig_callbackOnTap) {
2339     Dali::Toolkit::Internal::Control::OnTap(tap);
2340     return;
2341   } else {
2342     jtap = (Dali::TapGesture *) &tap;
2343     swig_callbackOnTap(jtap);
2344   }
2345 }
2346
2347 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2348   void * jlongPress = 0 ;
2349
2350   if (!swig_callbackOnLongPress) {
2351     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2352     return;
2353   } else {
2354     jlongPress = (Dali::LongPressGesture *) &longPress;
2355     swig_callbackOnLongPress(jlongPress);
2356   }
2357 }
2358
2359 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2360   void * jslotObserver = 0 ;
2361   void * jcallback = 0 ;
2362
2363   if (!swig_callbackSignalConnected) {
2364     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2365     return;
2366   } else {
2367     jslotObserver = (void *) slotObserver;
2368     jcallback = (void *) callback;
2369     swig_callbackSignalConnected(jslotObserver, jcallback);
2370   }
2371 }
2372
2373 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2374   void * jslotObserver = 0 ;
2375   void * jcallback = 0 ;
2376
2377   if (!swig_callbackSignalDisconnected) {
2378     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2379     return;
2380   } else {
2381     jslotObserver = (void *) slotObserver;
2382     jcallback = (void *) callback;
2383     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2384   }
2385 }
2386
2387 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2388   return Dali::Toolkit::Internal::Control::GetControlExtension();
2389 }
2390
2391 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) {
2392   swig_callbackOnStageConnection = callbackOnStageConnection;
2393   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2394   swig_callbackOnChildAdd = callbackOnChildAdd;
2395   swig_callbackOnChildRemove = callbackOnChildRemove;
2396   swig_callbackOnPropertySet = callbackOnPropertySet;
2397   swig_callbackOnSizeSet = callbackOnSizeSet;
2398   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2399   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2400   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2401   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2402   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2403   swig_callbackOnRelayout = callbackOnRelayout;
2404   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2405   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2406   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2407   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2408   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2409   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2410   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2411   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2412   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2413   swig_callbackOnInitialize = callbackOnInitialize;
2414   swig_callbackOnControlChildAdd = callbackOnControlChildAdd;
2415   swig_callbackOnControlChildRemove = callbackOnControlChildRemove;
2416   swig_callbackOnStyleChange = callbackOnStyleChange;
2417   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2418   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2419   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2420   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2421   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2422   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2423   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2424   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2425   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2426   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2427   swig_callbackOnPinch = callbackOnPinch;
2428   swig_callbackOnPan = callbackOnPan;
2429   swig_callbackOnTap = callbackOnTap;
2430   swig_callbackOnLongPress = callbackOnLongPress;
2431   swig_callbackSignalConnected = callbackSignalConnected;
2432   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2433 }
2434
2435 void SwigDirector_ViewImpl::swig_init_callbacks() {
2436   swig_callbackOnStageConnection = 0;
2437   swig_callbackOnStageDisconnection = 0;
2438   swig_callbackOnChildAdd = 0;
2439   swig_callbackOnChildRemove = 0;
2440   swig_callbackOnPropertySet = 0;
2441   swig_callbackOnSizeSet = 0;
2442   swig_callbackOnSizeAnimation = 0;
2443   swig_callbackOnTouchEvent = 0;
2444   swig_callbackOnHoverEvent = 0;
2445   swig_callbackOnKeyEvent = 0;
2446   swig_callbackOnWheelEvent = 0;
2447   swig_callbackOnRelayout = 0;
2448   swig_callbackOnSetResizePolicy = 0;
2449   swig_callbackGetNaturalSize = 0;
2450   swig_callbackCalculateChildSize = 0;
2451   swig_callbackGetHeightForWidth = 0;
2452   swig_callbackGetWidthForHeight = 0;
2453   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2454   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2455   swig_callbackOnCalculateRelayoutSize = 0;
2456   swig_callbackOnLayoutNegotiated = 0;
2457   swig_callbackOnInitialize = 0;
2458   swig_callbackOnControlChildAdd = 0;
2459   swig_callbackOnControlChildRemove = 0;
2460   swig_callbackOnStyleChange = 0;
2461   swig_callbackOnAccessibilityActivated = 0;
2462   swig_callbackOnAccessibilityPan = 0;
2463   swig_callbackOnAccessibilityTouch = 0;
2464   swig_callbackOnAccessibilityValueChange = 0;
2465   swig_callbackOnAccessibilityZoom = 0;
2466   swig_callbackOnKeyInputFocusGained = 0;
2467   swig_callbackOnKeyInputFocusLost = 0;
2468   swig_callbackGetNextKeyboardFocusableActor = 0;
2469   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2470   swig_callbackOnKeyboardEnter = 0;
2471   swig_callbackOnPinch = 0;
2472   swig_callbackOnPan = 0;
2473   swig_callbackOnTap = 0;
2474   swig_callbackOnLongPress = 0;
2475   swig_callbackSignalConnected = 0;
2476   swig_callbackSignalDisconnected = 0;
2477 }
2478
2479 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2480   swig_init_callbacks();
2481 }
2482
2483 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2484
2485 }
2486
2487
2488 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2489   unsigned int c_result = SwigValueInit< unsigned int >() ;
2490   unsigned int jresult = 0 ;
2491
2492   if (!swig_callbackGetNumberOfItems) {
2493     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2494   } else {
2495     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2496     c_result = (unsigned int)jresult;
2497   }
2498   return c_result;
2499 }
2500
2501 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2502   Dali::Actor c_result ;
2503   void * jresult = 0 ;
2504   unsigned int jitemId  ;
2505
2506   if (!swig_callbackNewItem) {
2507     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2508   } else {
2509     jitemId = itemId;
2510     jresult = (void *) swig_callbackNewItem(jitemId);
2511     if (!jresult) {
2512       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2513       return c_result;
2514     }
2515     c_result = *(Dali::Actor *)jresult;
2516   }
2517   return c_result;
2518 }
2519
2520 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2521   unsigned int jitemId  ;
2522   void * jactor  ;
2523
2524   if (!swig_callbackItemReleased) {
2525     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2526     return;
2527   } else {
2528     jitemId = itemId;
2529     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2530     swig_callbackItemReleased(jitemId, jactor);
2531   }
2532 }
2533
2534 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2535   return Dali::Toolkit::ItemFactory::GetExtension();
2536 }
2537
2538 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2539   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2540   swig_callbackNewItem = callbackNewItem;
2541   swig_callbackItemReleased = callbackItemReleased;
2542 }
2543
2544 void SwigDirector_ItemFactory::swig_init_callbacks() {
2545   swig_callbackGetNumberOfItems = 0;
2546   swig_callbackNewItem = 0;
2547   swig_callbackItemReleased = 0;
2548 }
2549
2550 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2551   swig_init_callbacks();
2552 }
2553
2554 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2555
2556 }
2557
2558
2559 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2560   Dali::Actor c_result ;
2561   void * jresult = 0 ;
2562   void * jcurrent  ;
2563   void * jproposed  ;
2564   int jdirection  ;
2565
2566   if (!swig_callbackGetNextFocusableActor) {
2567     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2568   } else {
2569     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2570     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2571     jdirection = (int)direction;
2572     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2573     if (!jresult) {
2574       DALI_LOG_ERROR("[ERROR][%s line:%d] Unexpected null return for type Dali::Actor! Next focus will be NULL, please be cautious to handle the keyboard foucs! ", __FILE__, __LINE__);
2575       return c_result;
2576     }
2577     c_result = *(Dali::Actor *)jresult;
2578   }
2579   return c_result;
2580 }
2581
2582 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2583   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2584 }
2585
2586 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2587   swig_callbackGetNextFocusableActor = 0;
2588 }
2589
2590
2591 #ifdef __cplusplus
2592 extern "C" {
2593 #endif
2594
2595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2596   void * jresult ;
2597   floatp *result = 0 ;
2598
2599   {
2600     try {
2601       result = (floatp *)new_floatp();
2602     } catch (std::out_of_range& e) {
2603       {
2604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2605       };
2606     } catch (std::exception& e) {
2607       {
2608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2609       };
2610     } catch (DaliException e) {
2611       {
2612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2613       };
2614     } catch (...) {
2615       {
2616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2617       };
2618     }
2619   }
2620   jresult = (void *)result;
2621   return jresult;
2622 }
2623
2624
2625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2626   floatp *arg1 = (floatp *) 0 ;
2627
2628   arg1 = (floatp *)jarg1;
2629   {
2630     try {
2631       delete_floatp(arg1);
2632     } catch (std::out_of_range& e) {
2633       {
2634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2635       };
2636     } catch (std::exception& e) {
2637       {
2638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2639       };
2640     } catch (Dali::DaliException e) {
2641       {
2642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2643       };
2644     } catch (...) {
2645       {
2646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2647       };
2648     }
2649   }
2650
2651 }
2652
2653
2654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2655   floatp *arg1 = (floatp *) 0 ;
2656   float arg2 ;
2657
2658   arg1 = (floatp *)jarg1;
2659   arg2 = (float)jarg2;
2660   {
2661     try {
2662       floatp_assign(arg1,arg2);
2663     } catch (std::out_of_range& e) {
2664       {
2665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2666       };
2667     } catch (std::exception& e) {
2668       {
2669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2670       };
2671     } catch (Dali::DaliException e) {
2672       {
2673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2674       };
2675     } catch (...) {
2676       {
2677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2678       };
2679     }
2680   }
2681
2682 }
2683
2684
2685 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2686   float jresult ;
2687   floatp *arg1 = (floatp *) 0 ;
2688   float result;
2689
2690   arg1 = (floatp *)jarg1;
2691   {
2692     try {
2693       result = (float)floatp_value(arg1);
2694     } catch (std::out_of_range& e) {
2695       {
2696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2697       };
2698     } catch (std::exception& e) {
2699       {
2700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2701       };
2702     } catch (DaliException e) {
2703       {
2704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2705       };
2706     } catch (...) {
2707       {
2708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2709       };
2710     }
2711   }
2712   jresult = result;
2713   return jresult;
2714 }
2715
2716
2717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2718   void * jresult ;
2719   floatp *arg1 = (floatp *) 0 ;
2720   float *result = 0 ;
2721
2722   arg1 = (floatp *)jarg1;
2723   {
2724     try {
2725       result = (float *)floatp_cast(arg1);
2726     } catch (std::out_of_range& e) {
2727       {
2728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2729       };
2730     } catch (std::exception& e) {
2731       {
2732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2733       };
2734     } catch (Dali::DaliException e) {
2735       {
2736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2737       };
2738     } catch (...) {
2739       {
2740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2741       };
2742     }
2743   }
2744
2745   jresult = (void *)result;
2746   return jresult;
2747 }
2748
2749
2750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2751   void * jresult ;
2752   float *arg1 = (float *) 0 ;
2753   floatp *result = 0 ;
2754
2755   arg1 = (float *)jarg1;
2756   {
2757     try {
2758       result = (floatp *)floatp_frompointer(arg1);
2759     } catch (std::out_of_range& e) {
2760       {
2761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2762       };
2763     } catch (std::exception& e) {
2764       {
2765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2766       };
2767     } catch (Dali::DaliException e) {
2768       {
2769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2770       };
2771     } catch (...) {
2772       {
2773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2774       };
2775     }
2776   }
2777
2778   jresult = (void *)result;
2779   return jresult;
2780 }
2781
2782
2783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2784   void * jresult ;
2785   intp *result = 0 ;
2786
2787   {
2788     try {
2789       result = (intp *)new_intp();
2790     } catch (std::out_of_range& e) {
2791       {
2792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2793       };
2794     } catch (std::exception& e) {
2795       {
2796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2797       };
2798     } catch (Dali::DaliException e) {
2799       {
2800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2801       };
2802     } catch (...) {
2803       {
2804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2805       };
2806     }
2807   }
2808
2809   jresult = (void *)result;
2810   return jresult;
2811 }
2812
2813
2814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2815   intp *arg1 = (intp *) 0 ;
2816
2817   arg1 = (intp *)jarg1;
2818   {
2819     try {
2820       delete_intp(arg1);
2821     } catch (std::out_of_range& e) {
2822       {
2823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2824       };
2825     } catch (std::exception& e) {
2826       {
2827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2828       };
2829     } catch (Dali::DaliException e) {
2830       {
2831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2832       };
2833     } catch (...) {
2834       {
2835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2836       };
2837     }
2838   }
2839
2840 }
2841
2842
2843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2844   intp *arg1 = (intp *) 0 ;
2845   int arg2 ;
2846
2847   arg1 = (intp *)jarg1;
2848   arg2 = (int)jarg2;
2849   {
2850     try {
2851       intp_assign(arg1,arg2);
2852     } catch (std::out_of_range& e) {
2853       {
2854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2855       };
2856     } catch (std::exception& e) {
2857       {
2858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2859       };
2860     } catch (Dali::DaliException e) {
2861       {
2862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2863       };
2864     } catch (...) {
2865       {
2866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2867       };
2868     }
2869   }
2870
2871 }
2872
2873
2874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2875   int jresult ;
2876   intp *arg1 = (intp *) 0 ;
2877   int result;
2878
2879   arg1 = (intp *)jarg1;
2880   {
2881     try {
2882       result = (int)intp_value(arg1);
2883     } catch (std::out_of_range& e) {
2884       {
2885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2886       };
2887     } catch (std::exception& e) {
2888       {
2889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2890       };
2891     } catch (Dali::DaliException e) {
2892       {
2893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2894       };
2895     } catch (...) {
2896       {
2897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2898       };
2899     }
2900   }
2901
2902   jresult = result;
2903   return jresult;
2904 }
2905
2906
2907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2908   void * jresult ;
2909   intp *arg1 = (intp *) 0 ;
2910   int *result = 0 ;
2911
2912   arg1 = (intp *)jarg1;
2913   {
2914     try {
2915       result = (int *)intp_cast(arg1);
2916     } catch (std::out_of_range& e) {
2917       {
2918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2919       };
2920     } catch (std::exception& e) {
2921       {
2922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2923       };
2924     } catch (Dali::DaliException e) {
2925       {
2926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2927       };
2928     } catch (...) {
2929       {
2930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2931       };
2932     }
2933   }
2934
2935   jresult = (void *)result;
2936   return jresult;
2937 }
2938
2939
2940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2941   void * jresult ;
2942   int *arg1 = (int *) 0 ;
2943   intp *result = 0 ;
2944
2945   arg1 = (int *)jarg1;
2946   {
2947     try {
2948       result = (intp *)intp_frompointer(arg1);
2949     } catch (std::out_of_range& e) {
2950       {
2951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2952       };
2953     } catch (std::exception& e) {
2954       {
2955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2956       };
2957     } catch (Dali::DaliException e) {
2958       {
2959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2960       };
2961     } catch (...) {
2962       {
2963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2964       };
2965     }
2966   }
2967
2968   jresult = (void *)result;
2969   return jresult;
2970 }
2971
2972
2973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2974   void * jresult ;
2975   doublep *result = 0 ;
2976
2977   {
2978     try {
2979       result = (doublep *)new_doublep();
2980     } catch (std::out_of_range& e) {
2981       {
2982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2983       };
2984     } catch (std::exception& e) {
2985       {
2986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2987       };
2988     } catch (Dali::DaliException e) {
2989       {
2990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2991       };
2992     } catch (...) {
2993       {
2994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2995       };
2996     }
2997   }
2998
2999   jresult = (void *)result;
3000   return jresult;
3001 }
3002
3003
3004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
3005   doublep *arg1 = (doublep *) 0 ;
3006
3007   arg1 = (doublep *)jarg1;
3008   {
3009     try {
3010       delete_doublep(arg1);
3011     } catch (std::out_of_range& e) {
3012       {
3013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3014       };
3015     } catch (std::exception& e) {
3016       {
3017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3018       };
3019     } catch (Dali::DaliException e) {
3020       {
3021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3022       };
3023     } catch (...) {
3024       {
3025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3026       };
3027     }
3028   }
3029
3030 }
3031
3032
3033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
3034   doublep *arg1 = (doublep *) 0 ;
3035   double arg2 ;
3036
3037   arg1 = (doublep *)jarg1;
3038   arg2 = (double)jarg2;
3039   {
3040     try {
3041       doublep_assign(arg1,arg2);
3042     } catch (std::out_of_range& e) {
3043       {
3044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3045       };
3046     } catch (std::exception& e) {
3047       {
3048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3049       };
3050     } catch (Dali::DaliException e) {
3051       {
3052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3053       };
3054     } catch (...) {
3055       {
3056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3057       };
3058     }
3059   }
3060
3061 }
3062
3063
3064 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3065   double jresult ;
3066   doublep *arg1 = (doublep *) 0 ;
3067   double result;
3068
3069   arg1 = (doublep *)jarg1;
3070   {
3071     try {
3072       result = (double)doublep_value(arg1);
3073     } catch (std::out_of_range& e) {
3074       {
3075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3076       };
3077     } catch (std::exception& e) {
3078       {
3079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3080       };
3081     } catch (Dali::DaliException e) {
3082       {
3083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3084       };
3085     } catch (...) {
3086       {
3087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3088       };
3089     }
3090   }
3091
3092   jresult = result;
3093   return jresult;
3094 }
3095
3096
3097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3098   void * jresult ;
3099   doublep *arg1 = (doublep *) 0 ;
3100   double *result = 0 ;
3101
3102   arg1 = (doublep *)jarg1;
3103   {
3104     try {
3105       result = (double *)doublep_cast(arg1);
3106     } catch (std::out_of_range& e) {
3107       {
3108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3109       };
3110     } catch (std::exception& e) {
3111       {
3112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3113       };
3114     } catch (Dali::DaliException e) {
3115       {
3116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3117       };
3118     } catch (...) {
3119       {
3120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3121       };
3122     }
3123   }
3124
3125   jresult = (void *)result;
3126   return jresult;
3127 }
3128
3129
3130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3131   void * jresult ;
3132   double *arg1 = (double *) 0 ;
3133   doublep *result = 0 ;
3134
3135   arg1 = (double *)jarg1;
3136   {
3137     try {
3138       result = (doublep *)doublep_frompointer(arg1);
3139     } catch (std::out_of_range& e) {
3140       {
3141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3142       };
3143     } catch (std::exception& e) {
3144       {
3145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3146       };
3147     } catch (Dali::DaliException e) {
3148       {
3149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3150       };
3151     } catch (...) {
3152       {
3153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3154       };
3155     }
3156   }
3157
3158   jresult = (void *)result;
3159   return jresult;
3160 }
3161
3162
3163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3164   void * jresult ;
3165   uintp *result = 0 ;
3166
3167   {
3168     try {
3169       result = (uintp *)new_uintp();
3170     } catch (std::out_of_range& e) {
3171       {
3172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3173       };
3174     } catch (std::exception& e) {
3175       {
3176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3177       };
3178     } catch (Dali::DaliException e) {
3179       {
3180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3181       };
3182     } catch (...) {
3183       {
3184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3185       };
3186     }
3187   }
3188
3189   jresult = (void *)result;
3190   return jresult;
3191 }
3192
3193
3194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3195   uintp *arg1 = (uintp *) 0 ;
3196
3197   arg1 = (uintp *)jarg1;
3198   {
3199     try {
3200       delete_uintp(arg1);
3201     } catch (std::out_of_range& e) {
3202       {
3203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3204       };
3205     } catch (std::exception& e) {
3206       {
3207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3208       };
3209     } catch (Dali::DaliException e) {
3210       {
3211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3212       };
3213     } catch (...) {
3214       {
3215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3216       };
3217     }
3218   }
3219
3220 }
3221
3222
3223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3224   uintp *arg1 = (uintp *) 0 ;
3225   unsigned int arg2 ;
3226
3227   arg1 = (uintp *)jarg1;
3228   arg2 = (unsigned int)jarg2;
3229   {
3230     try {
3231       uintp_assign(arg1,arg2);
3232     } catch (std::out_of_range& e) {
3233       {
3234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3235       };
3236     } catch (std::exception& e) {
3237       {
3238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3239       };
3240     } catch (Dali::DaliException e) {
3241       {
3242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3243       };
3244     } catch (...) {
3245       {
3246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3247       };
3248     }
3249   }
3250
3251 }
3252
3253
3254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3255   unsigned int jresult ;
3256   uintp *arg1 = (uintp *) 0 ;
3257   unsigned int result;
3258
3259   arg1 = (uintp *)jarg1;
3260   {
3261     try {
3262       result = (unsigned int)uintp_value(arg1);
3263     } catch (std::out_of_range& e) {
3264       {
3265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3266       };
3267     } catch (std::exception& e) {
3268       {
3269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3270       };
3271     } catch (Dali::DaliException e) {
3272       {
3273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3274       };
3275     } catch (...) {
3276       {
3277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3278       };
3279     }
3280   }
3281
3282   jresult = result;
3283   return jresult;
3284 }
3285
3286
3287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3288   void * jresult ;
3289   uintp *arg1 = (uintp *) 0 ;
3290   unsigned int *result = 0 ;
3291
3292   arg1 = (uintp *)jarg1;
3293   {
3294     try {
3295       result = (unsigned int *)uintp_cast(arg1);
3296     } catch (std::out_of_range& e) {
3297       {
3298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3299       };
3300     } catch (std::exception& e) {
3301       {
3302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3303       };
3304     } catch (Dali::DaliException e) {
3305       {
3306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3307       };
3308     } catch (...) {
3309       {
3310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3311       };
3312     }
3313   }
3314
3315   jresult = (void *)result;
3316   return jresult;
3317 }
3318
3319
3320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3321   void * jresult ;
3322   unsigned int *arg1 = (unsigned int *) 0 ;
3323   uintp *result = 0 ;
3324
3325   arg1 = (unsigned int *)jarg1;
3326   {
3327     try {
3328       result = (uintp *)uintp_frompointer(arg1);
3329     } catch (std::out_of_range& e) {
3330       {
3331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3332       };
3333     } catch (std::exception& e) {
3334       {
3335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3336       };
3337     } catch (Dali::DaliException e) {
3338       {
3339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3340       };
3341     } catch (...) {
3342       {
3343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3344       };
3345     }
3346   }
3347
3348   jresult = (void *)result;
3349   return jresult;
3350 }
3351
3352
3353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3354   void * jresult ;
3355   ushortp *result = 0 ;
3356
3357   {
3358     try {
3359       result = (ushortp *)new_ushortp();
3360     } catch (std::out_of_range& e) {
3361       {
3362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3363       };
3364     } catch (std::exception& e) {
3365       {
3366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3367       };
3368     } catch (Dali::DaliException e) {
3369       {
3370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3371       };
3372     } catch (...) {
3373       {
3374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3375       };
3376     }
3377   }
3378
3379   jresult = (void *)result;
3380   return jresult;
3381 }
3382
3383
3384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3385   ushortp *arg1 = (ushortp *) 0 ;
3386
3387   arg1 = (ushortp *)jarg1;
3388   {
3389     try {
3390       delete_ushortp(arg1);
3391     } catch (std::out_of_range& e) {
3392       {
3393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3394       };
3395     } catch (std::exception& e) {
3396       {
3397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3398       };
3399     } catch (Dali::DaliException e) {
3400       {
3401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3402       };
3403     } catch (...) {
3404       {
3405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3406       };
3407     }
3408   }
3409
3410 }
3411
3412
3413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3414   ushortp *arg1 = (ushortp *) 0 ;
3415   unsigned short arg2 ;
3416
3417   arg1 = (ushortp *)jarg1;
3418   arg2 = (unsigned short)jarg2;
3419   {
3420     try {
3421       ushortp_assign(arg1,arg2);
3422     } catch (std::out_of_range& e) {
3423       {
3424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3425       };
3426     } catch (std::exception& e) {
3427       {
3428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3429       };
3430     } catch (Dali::DaliException e) {
3431       {
3432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3433       };
3434     } catch (...) {
3435       {
3436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3437       };
3438     }
3439   }
3440
3441 }
3442
3443
3444 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3445   unsigned short jresult ;
3446   ushortp *arg1 = (ushortp *) 0 ;
3447   unsigned short result;
3448
3449   arg1 = (ushortp *)jarg1;
3450   {
3451     try {
3452       result = (unsigned short)ushortp_value(arg1);
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 (Dali::DaliException e) {
3462       {
3463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3464       };
3465     } catch (...) {
3466       {
3467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3468       };
3469     }
3470   }
3471
3472   jresult = result;
3473   return jresult;
3474 }
3475
3476
3477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3478   void * jresult ;
3479   ushortp *arg1 = (ushortp *) 0 ;
3480   unsigned short *result = 0 ;
3481
3482   arg1 = (ushortp *)jarg1;
3483   {
3484     try {
3485       result = (unsigned short *)ushortp_cast(arg1);
3486     } catch (std::out_of_range& e) {
3487       {
3488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3489       };
3490     } catch (std::exception& e) {
3491       {
3492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3493       };
3494     } catch (Dali::DaliException e) {
3495       {
3496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3497       };
3498     } catch (...) {
3499       {
3500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3501       };
3502     }
3503   }
3504
3505   jresult = (void *)result;
3506   return jresult;
3507 }
3508
3509
3510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3511   void * jresult ;
3512   unsigned short *arg1 = (unsigned short *) 0 ;
3513   ushortp *result = 0 ;
3514
3515   arg1 = (unsigned short *)jarg1;
3516   {
3517     try {
3518       result = (ushortp *)ushortp_frompointer(arg1);
3519     } catch (std::out_of_range& e) {
3520       {
3521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3522       };
3523     } catch (std::exception& e) {
3524       {
3525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3526       };
3527     } catch (Dali::DaliException e) {
3528       {
3529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3530       };
3531     } catch (...) {
3532       {
3533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3534       };
3535     }
3536   }
3537
3538   jresult = (void *)result;
3539   return jresult;
3540 }
3541
3542
3543 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3544   unsigned int jresult ;
3545   int arg1 ;
3546   unsigned int result;
3547
3548   arg1 = (int)jarg1;
3549   {
3550     try {
3551       result = (unsigned int)int_to_uint(arg1);
3552     } catch (std::out_of_range& e) {
3553       {
3554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3555       };
3556     } catch (std::exception& e) {
3557       {
3558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3559       };
3560     } catch (Dali::DaliException e) {
3561       {
3562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3563       };
3564     } catch (...) {
3565       {
3566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3567       };
3568     }
3569   }
3570
3571   jresult = result;
3572   return jresult;
3573 }
3574
3575
3576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3577   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3578
3579   arg1 = (Dali::RefObject *)jarg1;
3580   {
3581     try {
3582       (arg1)->Reference();
3583     } catch (std::out_of_range& e) {
3584       {
3585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3586       };
3587     } catch (std::exception& e) {
3588       {
3589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3590       };
3591     } catch (Dali::DaliException e) {
3592       {
3593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3594       };
3595     } catch (...) {
3596       {
3597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3598       };
3599     }
3600   }
3601
3602 }
3603
3604
3605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3606   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3607
3608   arg1 = (Dali::RefObject *)jarg1;
3609   {
3610     try {
3611       (arg1)->Unreference();
3612     } catch (std::out_of_range& e) {
3613       {
3614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3615       };
3616     } catch (std::exception& e) {
3617       {
3618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3619       };
3620     } catch (Dali::DaliException e) {
3621       {
3622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3623       };
3624     } catch (...) {
3625       {
3626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3627       };
3628     }
3629   }
3630
3631 }
3632
3633
3634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3635   int jresult ;
3636   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3637   int result;
3638
3639   arg1 = (Dali::RefObject *)jarg1;
3640   {
3641     try {
3642       result = (int)(arg1)->ReferenceCount();
3643     } catch (std::out_of_range& e) {
3644       {
3645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3646       };
3647     } catch (std::exception& e) {
3648       {
3649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3650       };
3651     } catch (Dali::DaliException e) {
3652       {
3653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3654       };
3655     } catch (...) {
3656       {
3657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3658       };
3659     }
3660   }
3661
3662   jresult = result;
3663   return jresult;
3664 }
3665
3666
3667 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3668   void * jresult ;
3669   Dali::Any *result = 0 ;
3670
3671   {
3672     try {
3673       result = (Dali::Any *)new Dali::Any();
3674     } catch (std::out_of_range& e) {
3675       {
3676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3677       };
3678     } catch (std::exception& e) {
3679       {
3680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3681       };
3682     } catch (Dali::DaliException e) {
3683       {
3684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3685       };
3686     } catch (...) {
3687       {
3688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3689       };
3690     }
3691   }
3692
3693   jresult = (void *)result;
3694   return jresult;
3695 }
3696
3697
3698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3699   Dali::Any *arg1 = (Dali::Any *) 0 ;
3700
3701   arg1 = (Dali::Any *)jarg1;
3702   {
3703     try {
3704       delete arg1;
3705     } catch (std::out_of_range& e) {
3706       {
3707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3708       };
3709     } catch (std::exception& e) {
3710       {
3711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3712       };
3713     } catch (Dali::DaliException e) {
3714       {
3715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3716       };
3717     } catch (...) {
3718       {
3719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3720       };
3721     }
3722   }
3723
3724 }
3725
3726
3727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3728   char *arg1 = (char *) 0 ;
3729
3730   arg1 = (char *)jarg1;
3731   {
3732     try {
3733       Dali::Any::AssertAlways((char const *)arg1);
3734     } catch (std::out_of_range& e) {
3735       {
3736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3737       };
3738     } catch (std::exception& e) {
3739       {
3740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3741       };
3742     } catch (Dali::DaliException e) {
3743       {
3744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3745       };
3746     } catch (...) {
3747       {
3748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3749       };
3750     }
3751   }
3752
3753 }
3754
3755
3756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3757   void * jresult ;
3758   Dali::Any *arg1 = 0 ;
3759   Dali::Any *result = 0 ;
3760
3761   arg1 = (Dali::Any *)jarg1;
3762   if (!arg1) {
3763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3764     return 0;
3765   }
3766   {
3767     try {
3768       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3769     } catch (std::out_of_range& e) {
3770       {
3771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3772       };
3773     } catch (std::exception& e) {
3774       {
3775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3776       };
3777     } catch (Dali::DaliException e) {
3778       {
3779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3780       };
3781     } catch (...) {
3782       {
3783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3784       };
3785     }
3786   }
3787
3788   jresult = (void *)result;
3789   return jresult;
3790 }
3791
3792
3793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3794   void * jresult ;
3795   Dali::Any *arg1 = (Dali::Any *) 0 ;
3796   Dali::Any *arg2 = 0 ;
3797   Dali::Any *result = 0 ;
3798
3799   arg1 = (Dali::Any *)jarg1;
3800   arg2 = (Dali::Any *)jarg2;
3801   if (!arg2) {
3802     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3803     return 0;
3804   }
3805   {
3806     try {
3807       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3808     } catch (std::out_of_range& e) {
3809       {
3810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3811       };
3812     } catch (std::exception& e) {
3813       {
3814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3815       };
3816     } catch (Dali::DaliException e) {
3817       {
3818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3819       };
3820     } catch (...) {
3821       {
3822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3823       };
3824     }
3825   }
3826
3827   jresult = (void *)result;
3828   return jresult;
3829 }
3830
3831
3832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3833   void * jresult ;
3834   Dali::Any *arg1 = (Dali::Any *) 0 ;
3835   std::type_info *result = 0 ;
3836
3837   arg1 = (Dali::Any *)jarg1;
3838   {
3839     try {
3840       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
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 (Dali::DaliException e) {
3850       {
3851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3852       };
3853     } catch (...) {
3854       {
3855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3856       };
3857     }
3858   }
3859
3860   jresult = (void *)result;
3861   return jresult;
3862 }
3863
3864
3865 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3866   unsigned int jresult ;
3867   Dali::Any *arg1 = (Dali::Any *) 0 ;
3868   bool result;
3869
3870   arg1 = (Dali::Any *)jarg1;
3871   {
3872     try {
3873       result = (bool)((Dali::Any const *)arg1)->Empty();
3874     } catch (std::out_of_range& e) {
3875       {
3876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3877       };
3878     } catch (std::exception& e) {
3879       {
3880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3881       };
3882     } catch (Dali::DaliException e) {
3883       {
3884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3885       };
3886     } catch (...) {
3887       {
3888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3889       };
3890     }
3891   }
3892
3893   jresult = result;
3894   return jresult;
3895 }
3896
3897
3898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3899   void * jresult ;
3900   std::type_info *arg1 = 0 ;
3901   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3902   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3903   Dali::Any::AnyContainerBase *result = 0 ;
3904
3905   arg1 = (std::type_info *)jarg1;
3906   if (!arg1) {
3907     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3908     return 0;
3909   }
3910   arg2 = (Dali::Any::CloneFunc)jarg2;
3911   arg3 = (Dali::Any::DeleteFunc)jarg3;
3912   {
3913     try {
3914       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3915     } catch (std::out_of_range& e) {
3916       {
3917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3918       };
3919     } catch (std::exception& e) {
3920       {
3921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3922       };
3923     } catch (Dali::DaliException e) {
3924       {
3925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3926       };
3927     } catch (...) {
3928       {
3929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3930       };
3931     }
3932   }
3933
3934   jresult = (void *)result;
3935   return jresult;
3936 }
3937
3938
3939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3940   void * jresult ;
3941   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3942   std::type_info *result = 0 ;
3943
3944   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3945   {
3946     try {
3947       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3948     } catch (std::out_of_range& e) {
3949       {
3950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3951       };
3952     } catch (std::exception& e) {
3953       {
3954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3955       };
3956     } catch (Dali::DaliException e) {
3957       {
3958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3959       };
3960     } catch (...) {
3961       {
3962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3963       };
3964     }
3965   }
3966
3967   jresult = (void *)result;
3968   return jresult;
3969 }
3970
3971
3972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3973   void * jresult ;
3974   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3975   ::std::type_info *result = 0 ;
3976
3977   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3978   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3979   jresult = (void *)result;
3980   return jresult;
3981 }
3982
3983
3984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3985   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3986   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3987
3988   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3989   arg2 = (Dali::Any::CloneFunc)jarg2;
3990   if (arg1) (arg1)->mCloneFunc = arg2;
3991 }
3992
3993
3994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3995   void * jresult ;
3996   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3997   Dali::Any::CloneFunc result;
3998
3999   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4000   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
4001   jresult = (void *)result;
4002   return jresult;
4003 }
4004
4005
4006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
4007   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4008   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
4009
4010   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4011   arg2 = (Dali::Any::DeleteFunc)jarg2;
4012   if (arg1) (arg1)->mDeleteFunc = arg2;
4013 }
4014
4015
4016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
4017   void * jresult ;
4018   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4019   Dali::Any::DeleteFunc result;
4020
4021   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4022   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
4023   jresult = (void *)result;
4024   return jresult;
4025 }
4026
4027
4028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
4029   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
4030
4031   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
4032   {
4033     try {
4034       delete arg1;
4035     } catch (std::out_of_range& e) {
4036       {
4037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4038       };
4039     } catch (std::exception& e) {
4040       {
4041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4042       };
4043     } catch (Dali::DaliException e) {
4044       {
4045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4046       };
4047     } catch (...) {
4048       {
4049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4050       };
4051     }
4052   }
4053
4054 }
4055
4056
4057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4058   Dali::Any *arg1 = (Dali::Any *) 0 ;
4059   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4060
4061   arg1 = (Dali::Any *)jarg1;
4062   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4063   if (arg1) (arg1)->mContainer = arg2;
4064 }
4065
4066
4067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4068   void * jresult ;
4069   Dali::Any *arg1 = (Dali::Any *) 0 ;
4070   Dali::Any::AnyContainerBase *result = 0 ;
4071
4072   arg1 = (Dali::Any *)jarg1;
4073   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4074   jresult = (void *)result;
4075   return jresult;
4076 }
4077
4078
4079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4080   char *arg1 = (char *) 0 ;
4081   char *arg2 = (char *) 0 ;
4082
4083   arg1 = (char *)jarg1;
4084   arg2 = (char *)jarg2;
4085   {
4086     try {
4087       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4088     } catch (std::out_of_range& e) {
4089       {
4090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4091       };
4092     } catch (std::exception& e) {
4093       {
4094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4095       };
4096     } catch (Dali::DaliException e) {
4097       {
4098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4099       };
4100     } catch (...) {
4101       {
4102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4103       };
4104     }
4105   }
4106
4107 }
4108
4109
4110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4111   void * jresult ;
4112   char *arg1 = (char *) 0 ;
4113   char *arg2 = (char *) 0 ;
4114   Dali::DaliException *result = 0 ;
4115
4116   arg1 = (char *)jarg1;
4117   arg2 = (char *)jarg2;
4118   {
4119     try {
4120       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4121     } catch (std::out_of_range& e) {
4122       {
4123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4124       };
4125     } catch (std::exception& e) {
4126       {
4127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4128       };
4129     } catch (Dali::DaliException e) {
4130       {
4131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4132       };
4133     } catch (...) {
4134       {
4135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4136       };
4137     }
4138   }
4139
4140   jresult = (void *)result;
4141   return jresult;
4142 }
4143
4144
4145 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4146   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4147   std::string arg2 = std::string(jarg2);
4148
4149   arg1 = (Dali::DaliException *)jarg1;
4150   {
4151     if (!arg2.empty()) {
4152       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4153     } else {
4154       arg1->location = 0;
4155     }
4156   }
4157 }
4158
4159 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4160   char * jresult ;
4161   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4162   char *result = 0 ;
4163
4164   arg1 = (Dali::DaliException *)jarg1;
4165   result = (char *) ((arg1)->location);
4166   jresult = SWIG_csharp_string_callback((const char *)result);
4167   return jresult;
4168 }
4169
4170
4171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4172   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4173   std::string arg2 = std::string(jarg2);
4174
4175   arg1 = (Dali::DaliException *)jarg1;
4176   {
4177     if (!arg2.empty()) {
4178       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4179     } else {
4180       arg1->condition = 0;
4181     }
4182   }
4183 }
4184
4185
4186 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4187   char * jresult ;
4188   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4189   char *result = 0 ;
4190
4191   arg1 = (Dali::DaliException *)jarg1;
4192   result = (char *) ((arg1)->condition);
4193   jresult = SWIG_csharp_string_callback((const char *)result);
4194   return jresult;
4195 }
4196
4197
4198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4199   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4200
4201   arg1 = (Dali::DaliException *)jarg1;
4202   {
4203     try {
4204       delete arg1;
4205     } catch (std::out_of_range& e) {
4206       {
4207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4208       };
4209     } catch (std::exception& e) {
4210       {
4211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4212       };
4213     } catch (Dali::DaliException e) {
4214       {
4215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4216       };
4217     } catch (...) {
4218       {
4219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4220       };
4221     }
4222   }
4223
4224 }
4225
4226
4227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4228   void * jresult ;
4229   Dali::Vector2 *result = 0 ;
4230
4231   {
4232     try {
4233       result = (Dali::Vector2 *)new Dali::Vector2();
4234     } catch (std::out_of_range& e) {
4235       {
4236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4237       };
4238     } catch (std::exception& e) {
4239       {
4240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4241       };
4242     } catch (Dali::DaliException e) {
4243       {
4244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4245       };
4246     } catch (...) {
4247       {
4248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4249       };
4250     }
4251   }
4252
4253   jresult = (void *)result;
4254   return jresult;
4255 }
4256
4257
4258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4259   void * jresult ;
4260   float arg1 ;
4261   float arg2 ;
4262   Dali::Vector2 *result = 0 ;
4263
4264   arg1 = (float)jarg1;
4265   arg2 = (float)jarg2;
4266   {
4267     try {
4268       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4269     } catch (std::out_of_range& e) {
4270       {
4271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4272       };
4273     } catch (std::exception& e) {
4274       {
4275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4276       };
4277     } catch (Dali::DaliException e) {
4278       {
4279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4280       };
4281     } catch (...) {
4282       {
4283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4284       };
4285     }
4286   }
4287
4288   jresult = (void *)result;
4289   return jresult;
4290 }
4291
4292
4293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4294   void * jresult ;
4295   float *arg1 = (float *) 0 ;
4296   Dali::Vector2 *result = 0 ;
4297
4298   arg1 = jarg1;
4299   {
4300     try {
4301       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4302     } catch (std::out_of_range& e) {
4303       {
4304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4305       };
4306     } catch (std::exception& e) {
4307       {
4308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4309       };
4310     } catch (Dali::DaliException e) {
4311       {
4312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4313       };
4314     } catch (...) {
4315       {
4316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4317       };
4318     }
4319   }
4320
4321   jresult = (void *)result;
4322
4323
4324   return jresult;
4325 }
4326
4327
4328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4329   void * jresult ;
4330   Dali::Vector3 *arg1 = 0 ;
4331   Dali::Vector2 *result = 0 ;
4332
4333   arg1 = (Dali::Vector3 *)jarg1;
4334   if (!arg1) {
4335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4336     return 0;
4337   }
4338   {
4339     try {
4340       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4341     } catch (std::out_of_range& e) {
4342       {
4343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4344       };
4345     } catch (std::exception& e) {
4346       {
4347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4348       };
4349     } catch (Dali::DaliException e) {
4350       {
4351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4352       };
4353     } catch (...) {
4354       {
4355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4356       };
4357     }
4358   }
4359
4360   jresult = (void *)result;
4361   return jresult;
4362 }
4363
4364
4365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4366   void * jresult ;
4367   Dali::Vector4 *arg1 = 0 ;
4368   Dali::Vector2 *result = 0 ;
4369
4370   arg1 = (Dali::Vector4 *)jarg1;
4371   if (!arg1) {
4372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4373     return 0;
4374   }
4375   {
4376     try {
4377       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4378     } catch (std::out_of_range& e) {
4379       {
4380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4381       };
4382     } catch (std::exception& e) {
4383       {
4384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4385       };
4386     } catch (Dali::DaliException e) {
4387       {
4388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4389       };
4390     } catch (...) {
4391       {
4392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4393       };
4394     }
4395   }
4396
4397   jresult = (void *)result;
4398   return jresult;
4399 }
4400
4401
4402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4403   void * jresult ;
4404   Dali::Vector2 *result = 0 ;
4405
4406   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4407   jresult = (void *)result;
4408   return jresult;
4409 }
4410
4411
4412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4413   void * jresult ;
4414   Dali::Vector2 *result = 0 ;
4415
4416   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4417   jresult = (void *)result;
4418   return jresult;
4419 }
4420
4421
4422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4423   void * jresult ;
4424   Dali::Vector2 *result = 0 ;
4425
4426   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4427   jresult = (void *)result;
4428   return jresult;
4429 }
4430
4431
4432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4433   void * jresult ;
4434   Dali::Vector2 *result = 0 ;
4435
4436   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4437   jresult = (void *)result;
4438   return jresult;
4439 }
4440
4441
4442 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4443   void * jresult ;
4444   Dali::Vector2 *result = 0 ;
4445
4446   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4447   jresult = (void *)result;
4448   return jresult;
4449 }
4450
4451
4452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4453   void * jresult ;
4454   Dali::Vector2 *result = 0 ;
4455
4456   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4457   jresult = (void *)result;
4458   return jresult;
4459 }
4460
4461
4462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4463   void * jresult ;
4464   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4465   float *arg2 = (float *) 0 ;
4466   Dali::Vector2 *result = 0 ;
4467
4468   arg1 = (Dali::Vector2 *)jarg1;
4469   arg2 = jarg2;
4470   {
4471     try {
4472       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4473     } catch (std::out_of_range& e) {
4474       {
4475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4476       };
4477     } catch (std::exception& e) {
4478       {
4479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4480       };
4481     } catch (Dali::DaliException e) {
4482       {
4483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4484       };
4485     } catch (...) {
4486       {
4487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4488       };
4489     }
4490   }
4491
4492   jresult = (void *)result;
4493
4494
4495   return jresult;
4496 }
4497
4498
4499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4500   void * jresult ;
4501   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4502   Dali::Vector3 *arg2 = 0 ;
4503   Dali::Vector2 *result = 0 ;
4504
4505   arg1 = (Dali::Vector2 *)jarg1;
4506   arg2 = (Dali::Vector3 *)jarg2;
4507   if (!arg2) {
4508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4509     return 0;
4510   }
4511   {
4512     try {
4513       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4514     } catch (std::out_of_range& e) {
4515       {
4516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4517       };
4518     } catch (std::exception& e) {
4519       {
4520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4521       };
4522     } catch (Dali::DaliException e) {
4523       {
4524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4525       };
4526     } catch (...) {
4527       {
4528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4529       };
4530     }
4531   }
4532
4533   jresult = (void *)result;
4534   return jresult;
4535 }
4536
4537
4538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4539   void * jresult ;
4540   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4541   Dali::Vector4 *arg2 = 0 ;
4542   Dali::Vector2 *result = 0 ;
4543
4544   arg1 = (Dali::Vector2 *)jarg1;
4545   arg2 = (Dali::Vector4 *)jarg2;
4546   if (!arg2) {
4547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4548     return 0;
4549   }
4550   {
4551     try {
4552       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4553     } catch (std::out_of_range& e) {
4554       {
4555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4556       };
4557     } catch (std::exception& e) {
4558       {
4559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4560       };
4561     } catch (Dali::DaliException e) {
4562       {
4563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4564       };
4565     } catch (...) {
4566       {
4567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4568       };
4569     }
4570   }
4571
4572   jresult = (void *)result;
4573   return jresult;
4574 }
4575
4576
4577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4578   void * jresult ;
4579   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4580   Dali::Vector2 *arg2 = 0 ;
4581   Dali::Vector2 result;
4582
4583   arg1 = (Dali::Vector2 *)jarg1;
4584   arg2 = (Dali::Vector2 *)jarg2;
4585   if (!arg2) {
4586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4587     return 0;
4588   }
4589   {
4590     try {
4591       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4592     } catch (std::out_of_range& e) {
4593       {
4594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4595       };
4596     } catch (std::exception& e) {
4597       {
4598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4599       };
4600     } catch (Dali::DaliException e) {
4601       {
4602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4603       };
4604     } catch (...) {
4605       {
4606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4607       };
4608     }
4609   }
4610
4611   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4612   return jresult;
4613 }
4614
4615
4616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4617   void * jresult ;
4618   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4619   Dali::Vector2 *arg2 = 0 ;
4620   Dali::Vector2 *result = 0 ;
4621
4622   arg1 = (Dali::Vector2 *)jarg1;
4623   arg2 = (Dali::Vector2 *)jarg2;
4624   if (!arg2) {
4625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4626     return 0;
4627   }
4628   {
4629     try {
4630       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4631     } catch (std::out_of_range& e) {
4632       {
4633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4634       };
4635     } catch (std::exception& e) {
4636       {
4637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4638       };
4639     } catch (Dali::DaliException e) {
4640       {
4641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4642       };
4643     } catch (...) {
4644       {
4645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4646       };
4647     }
4648   }
4649
4650   jresult = (void *)result;
4651   return jresult;
4652 }
4653
4654
4655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4656   void * jresult ;
4657   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4658   Dali::Vector2 *arg2 = 0 ;
4659   Dali::Vector2 result;
4660
4661   arg1 = (Dali::Vector2 *)jarg1;
4662   arg2 = (Dali::Vector2 *)jarg2;
4663   if (!arg2) {
4664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4665     return 0;
4666   }
4667   {
4668     try {
4669       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4670     } catch (std::out_of_range& e) {
4671       {
4672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4673       };
4674     } catch (std::exception& e) {
4675       {
4676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4677       };
4678     } catch (Dali::DaliException e) {
4679       {
4680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4681       };
4682     } catch (...) {
4683       {
4684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4685       };
4686     }
4687   }
4688
4689   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4690   return jresult;
4691 }
4692
4693
4694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4695   void * jresult ;
4696   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4697   Dali::Vector2 *arg2 = 0 ;
4698   Dali::Vector2 *result = 0 ;
4699
4700   arg1 = (Dali::Vector2 *)jarg1;
4701   arg2 = (Dali::Vector2 *)jarg2;
4702   if (!arg2) {
4703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4704     return 0;
4705   }
4706   {
4707     try {
4708       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4709     } catch (std::out_of_range& e) {
4710       {
4711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4712       };
4713     } catch (std::exception& e) {
4714       {
4715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4716       };
4717     } catch (Dali::DaliException e) {
4718       {
4719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4720       };
4721     } catch (...) {
4722       {
4723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4724       };
4725     }
4726   }
4727
4728   jresult = (void *)result;
4729   return jresult;
4730 }
4731
4732
4733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4734   void * jresult ;
4735   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4736   Dali::Vector2 *arg2 = 0 ;
4737   Dali::Vector2 result;
4738
4739   arg1 = (Dali::Vector2 *)jarg1;
4740   arg2 = (Dali::Vector2 *)jarg2;
4741   if (!arg2) {
4742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4743     return 0;
4744   }
4745   {
4746     try {
4747       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4748     } catch (std::out_of_range& e) {
4749       {
4750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4751       };
4752     } catch (std::exception& e) {
4753       {
4754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4755       };
4756     } catch (Dali::DaliException e) {
4757       {
4758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4759       };
4760     } catch (...) {
4761       {
4762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4763       };
4764     }
4765   }
4766
4767   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4768   return jresult;
4769 }
4770
4771
4772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4773   void * jresult ;
4774   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4775   float arg2 ;
4776   Dali::Vector2 result;
4777
4778   arg1 = (Dali::Vector2 *)jarg1;
4779   arg2 = (float)jarg2;
4780   {
4781     try {
4782       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4783     } catch (std::out_of_range& e) {
4784       {
4785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4786       };
4787     } catch (std::exception& e) {
4788       {
4789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4790       };
4791     } catch (Dali::DaliException e) {
4792       {
4793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4794       };
4795     } catch (...) {
4796       {
4797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4798       };
4799     }
4800   }
4801
4802   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4803   return jresult;
4804 }
4805
4806
4807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4808   void * jresult ;
4809   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4810   Dali::Vector2 *arg2 = 0 ;
4811   Dali::Vector2 *result = 0 ;
4812
4813   arg1 = (Dali::Vector2 *)jarg1;
4814   arg2 = (Dali::Vector2 *)jarg2;
4815   if (!arg2) {
4816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4817     return 0;
4818   }
4819   {
4820     try {
4821       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4822     } catch (std::out_of_range& e) {
4823       {
4824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4825       };
4826     } catch (std::exception& e) {
4827       {
4828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4829       };
4830     } catch (Dali::DaliException e) {
4831       {
4832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4833       };
4834     } catch (...) {
4835       {
4836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4837       };
4838     }
4839   }
4840
4841   jresult = (void *)result;
4842   return jresult;
4843 }
4844
4845
4846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4847   void * jresult ;
4848   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4849   float arg2 ;
4850   Dali::Vector2 *result = 0 ;
4851
4852   arg1 = (Dali::Vector2 *)jarg1;
4853   arg2 = (float)jarg2;
4854   {
4855     try {
4856       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4857     } catch (std::out_of_range& e) {
4858       {
4859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4860       };
4861     } catch (std::exception& e) {
4862       {
4863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4864       };
4865     } catch (Dali::DaliException e) {
4866       {
4867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4868       };
4869     } catch (...) {
4870       {
4871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4872       };
4873     }
4874   }
4875
4876   jresult = (void *)result;
4877   return jresult;
4878 }
4879
4880
4881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4882   void * jresult ;
4883   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4884   Dali::Vector2 *arg2 = 0 ;
4885   Dali::Vector2 result;
4886
4887   arg1 = (Dali::Vector2 *)jarg1;
4888   arg2 = (Dali::Vector2 *)jarg2;
4889   if (!arg2) {
4890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4891     return 0;
4892   }
4893   {
4894     try {
4895       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4896     } catch (std::out_of_range& e) {
4897       {
4898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4899       };
4900     } catch (std::exception& e) {
4901       {
4902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4903       };
4904     } catch (Dali::DaliException e) {
4905       {
4906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4907       };
4908     } catch (...) {
4909       {
4910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4911       };
4912     }
4913   }
4914
4915   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4916   return jresult;
4917 }
4918
4919
4920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4921   void * jresult ;
4922   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4923   float arg2 ;
4924   Dali::Vector2 result;
4925
4926   arg1 = (Dali::Vector2 *)jarg1;
4927   arg2 = (float)jarg2;
4928   {
4929     try {
4930       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4931     } catch (std::out_of_range& e) {
4932       {
4933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4934       };
4935     } catch (std::exception& e) {
4936       {
4937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4938       };
4939     } catch (Dali::DaliException e) {
4940       {
4941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4942       };
4943     } catch (...) {
4944       {
4945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4946       };
4947     }
4948   }
4949
4950   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4951   return jresult;
4952 }
4953
4954
4955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4956   void * jresult ;
4957   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4958   Dali::Vector2 *arg2 = 0 ;
4959   Dali::Vector2 *result = 0 ;
4960
4961   arg1 = (Dali::Vector2 *)jarg1;
4962   arg2 = (Dali::Vector2 *)jarg2;
4963   if (!arg2) {
4964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4965     return 0;
4966   }
4967   {
4968     try {
4969       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4970     } catch (std::out_of_range& e) {
4971       {
4972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4973       };
4974     } catch (std::exception& e) {
4975       {
4976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4977       };
4978     } catch (Dali::DaliException e) {
4979       {
4980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4981       };
4982     } catch (...) {
4983       {
4984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4985       };
4986     }
4987   }
4988
4989   jresult = (void *)result;
4990   return jresult;
4991 }
4992
4993
4994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4995   void * jresult ;
4996   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4997   float arg2 ;
4998   Dali::Vector2 *result = 0 ;
4999
5000   arg1 = (Dali::Vector2 *)jarg1;
5001   arg2 = (float)jarg2;
5002   {
5003     try {
5004       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
5005     } catch (std::out_of_range& e) {
5006       {
5007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5008       };
5009     } catch (std::exception& e) {
5010       {
5011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5012       };
5013     } catch (Dali::DaliException e) {
5014       {
5015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5016       };
5017     } catch (...) {
5018       {
5019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5020       };
5021     }
5022   }
5023
5024   jresult = (void *)result;
5025   return jresult;
5026 }
5027
5028
5029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
5030   void * jresult ;
5031   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5032   Dali::Vector2 result;
5033
5034   arg1 = (Dali::Vector2 *)jarg1;
5035   {
5036     try {
5037       result = ((Dali::Vector2 const *)arg1)->operator -();
5038     } catch (std::out_of_range& e) {
5039       {
5040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5041       };
5042     } catch (std::exception& e) {
5043       {
5044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5045       };
5046     } catch (Dali::DaliException e) {
5047       {
5048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5049       };
5050     } catch (...) {
5051       {
5052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5053       };
5054     }
5055   }
5056
5057   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5058   return jresult;
5059 }
5060
5061
5062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5063   unsigned int jresult ;
5064   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5065   Dali::Vector2 *arg2 = 0 ;
5066   bool result;
5067
5068   arg1 = (Dali::Vector2 *)jarg1;
5069   arg2 = (Dali::Vector2 *)jarg2;
5070   if (!arg2) {
5071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5072     return 0;
5073   }
5074   {
5075     try {
5076       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5077     } catch (std::out_of_range& e) {
5078       {
5079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5080       };
5081     } catch (std::exception& e) {
5082       {
5083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5084       };
5085     } catch (Dali::DaliException e) {
5086       {
5087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5088       };
5089     } catch (...) {
5090       {
5091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5092       };
5093     }
5094   }
5095
5096   jresult = result;
5097   return jresult;
5098 }
5099
5100
5101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5102   unsigned int jresult ;
5103   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5104   Dali::Vector2 *arg2 = 0 ;
5105   bool result;
5106
5107   arg1 = (Dali::Vector2 *)jarg1;
5108   arg2 = (Dali::Vector2 *)jarg2;
5109   if (!arg2) {
5110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5111     return 0;
5112   }
5113   {
5114     try {
5115       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5116     } catch (std::out_of_range& e) {
5117       {
5118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5119       };
5120     } catch (std::exception& e) {
5121       {
5122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5123       };
5124     } catch (Dali::DaliException e) {
5125       {
5126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5127       };
5128     } catch (...) {
5129       {
5130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5131       };
5132     }
5133   }
5134
5135   jresult = result;
5136   return jresult;
5137 }
5138
5139
5140 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5141   float jresult ;
5142   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5143   unsigned int arg2 ;
5144   float *result = 0 ;
5145
5146   arg1 = (Dali::Vector2 *)jarg1;
5147   arg2 = (unsigned int)jarg2;
5148   {
5149     try {
5150       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5151     } catch (std::out_of_range& e) {
5152       {
5153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5154       };
5155     } catch (std::exception& e) {
5156       {
5157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5158       };
5159     } catch (Dali::DaliException e) {
5160       {
5161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5162       };
5163     } catch (...) {
5164       {
5165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5166       };
5167     }
5168   }
5169
5170   jresult = *result;
5171   return jresult;
5172 }
5173
5174
5175 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5176   float jresult ;
5177   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5178   float result;
5179
5180   arg1 = (Dali::Vector2 *)jarg1;
5181   {
5182     try {
5183       result = (float)((Dali::Vector2 const *)arg1)->Length();
5184     } catch (std::out_of_range& e) {
5185       {
5186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5187       };
5188     } catch (std::exception& e) {
5189       {
5190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5191       };
5192     } catch (Dali::DaliException e) {
5193       {
5194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5195       };
5196     } catch (...) {
5197       {
5198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5199       };
5200     }
5201   }
5202
5203   jresult = result;
5204   return jresult;
5205 }
5206
5207
5208 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5209   float jresult ;
5210   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5211   float result;
5212
5213   arg1 = (Dali::Vector2 *)jarg1;
5214   {
5215     try {
5216       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5217     } catch (std::out_of_range& e) {
5218       {
5219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5220       };
5221     } catch (std::exception& e) {
5222       {
5223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5224       };
5225     } catch (Dali::DaliException e) {
5226       {
5227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5228       };
5229     } catch (...) {
5230       {
5231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5232       };
5233     }
5234   }
5235
5236   jresult = result;
5237   return jresult;
5238 }
5239
5240
5241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5242   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5243
5244   arg1 = (Dali::Vector2 *)jarg1;
5245   {
5246     try {
5247       (arg1)->Normalize();
5248     } catch (std::out_of_range& e) {
5249       {
5250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5251       };
5252     } catch (std::exception& e) {
5253       {
5254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5255       };
5256     } catch (Dali::DaliException e) {
5257       {
5258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5259       };
5260     } catch (...) {
5261       {
5262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5263       };
5264     }
5265   }
5266
5267 }
5268
5269
5270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5271   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5272   Dali::Vector2 *arg2 = 0 ;
5273   Dali::Vector2 *arg3 = 0 ;
5274
5275   arg1 = (Dali::Vector2 *)jarg1;
5276   arg2 = (Dali::Vector2 *)jarg2;
5277   if (!arg2) {
5278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5279     return ;
5280   }
5281   arg3 = (Dali::Vector2 *)jarg3;
5282   if (!arg3) {
5283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5284     return ;
5285   }
5286   {
5287     try {
5288       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5289     } catch (std::out_of_range& e) {
5290       {
5291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5292       };
5293     } catch (std::exception& e) {
5294       {
5295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5296       };
5297     } catch (Dali::DaliException e) {
5298       {
5299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5300       };
5301     } catch (...) {
5302       {
5303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5304       };
5305     }
5306   }
5307
5308 }
5309
5310
5311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5312   void * jresult ;
5313   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5314   float *result = 0 ;
5315
5316   arg1 = (Dali::Vector2 *)jarg1;
5317   {
5318     try {
5319       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5320     } catch (std::out_of_range& e) {
5321       {
5322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5323       };
5324     } catch (std::exception& e) {
5325       {
5326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5327       };
5328     } catch (Dali::DaliException e) {
5329       {
5330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5331       };
5332     } catch (...) {
5333       {
5334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5335       };
5336     }
5337   }
5338
5339   jresult = (void *)result;
5340   return jresult;
5341 }
5342
5343
5344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5345   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5346   float arg2 ;
5347
5348   arg1 = (Dali::Vector2 *)jarg1;
5349   arg2 = (float)jarg2;
5350   if (arg1) (arg1)->x = arg2;
5351 }
5352
5353
5354 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5355   float jresult ;
5356   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5357   float result;
5358
5359   arg1 = (Dali::Vector2 *)jarg1;
5360   result = (float) ((arg1)->x);
5361   jresult = result;
5362   return jresult;
5363 }
5364
5365
5366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5367   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5368   float arg2 ;
5369
5370   arg1 = (Dali::Vector2 *)jarg1;
5371   arg2 = (float)jarg2;
5372   if (arg1) (arg1)->width = arg2;
5373 }
5374
5375
5376 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5377   float jresult ;
5378   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5379   float result;
5380
5381   arg1 = (Dali::Vector2 *)jarg1;
5382   result = (float) ((arg1)->width);
5383   jresult = result;
5384   return jresult;
5385 }
5386
5387
5388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5389   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5390   float arg2 ;
5391
5392   arg1 = (Dali::Vector2 *)jarg1;
5393   arg2 = (float)jarg2;
5394   if (arg1) (arg1)->y = arg2;
5395 }
5396
5397
5398 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5399   float jresult ;
5400   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5401   float result;
5402
5403   arg1 = (Dali::Vector2 *)jarg1;
5404   result = (float) ((arg1)->y);
5405   jresult = result;
5406   return jresult;
5407 }
5408
5409
5410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5411   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5412   float arg2 ;
5413
5414   arg1 = (Dali::Vector2 *)jarg1;
5415   arg2 = (float)jarg2;
5416   if (arg1) (arg1)->height = arg2;
5417 }
5418
5419
5420 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5421   float jresult ;
5422   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5423   float result;
5424
5425   arg1 = (Dali::Vector2 *)jarg1;
5426   result = (float) ((arg1)->height);
5427   jresult = result;
5428   return jresult;
5429 }
5430
5431
5432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5433   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5434
5435   arg1 = (Dali::Vector2 *)jarg1;
5436   {
5437     try {
5438       delete arg1;
5439     } catch (std::out_of_range& e) {
5440       {
5441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5442       };
5443     } catch (std::exception& e) {
5444       {
5445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5446       };
5447     } catch (Dali::DaliException e) {
5448       {
5449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5450       };
5451     } catch (...) {
5452       {
5453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5454       };
5455     }
5456   }
5457
5458 }
5459
5460
5461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5462   void * jresult ;
5463   Dali::Vector2 *arg1 = 0 ;
5464   Dali::Vector2 *arg2 = 0 ;
5465   Dali::Vector2 result;
5466
5467   arg1 = (Dali::Vector2 *)jarg1;
5468   if (!arg1) {
5469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5470     return 0;
5471   }
5472   arg2 = (Dali::Vector2 *)jarg2;
5473   if (!arg2) {
5474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5475     return 0;
5476   }
5477   {
5478     try {
5479       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5480     } catch (std::out_of_range& e) {
5481       {
5482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5483       };
5484     } catch (std::exception& e) {
5485       {
5486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5487       };
5488     } catch (Dali::DaliException e) {
5489       {
5490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5491       };
5492     } catch (...) {
5493       {
5494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5495       };
5496     }
5497   }
5498
5499   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5500   return jresult;
5501 }
5502
5503
5504 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5505   void * jresult ;
5506   Dali::Vector2 *arg1 = 0 ;
5507   Dali::Vector2 *arg2 = 0 ;
5508   Dali::Vector2 result;
5509
5510   arg1 = (Dali::Vector2 *)jarg1;
5511   if (!arg1) {
5512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5513     return 0;
5514   }
5515   arg2 = (Dali::Vector2 *)jarg2;
5516   if (!arg2) {
5517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5518     return 0;
5519   }
5520   {
5521     try {
5522       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5523     } catch (std::out_of_range& e) {
5524       {
5525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5526       };
5527     } catch (std::exception& e) {
5528       {
5529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5530       };
5531     } catch (Dali::DaliException e) {
5532       {
5533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5534       };
5535     } catch (...) {
5536       {
5537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5538       };
5539     }
5540   }
5541
5542   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5543   return jresult;
5544 }
5545
5546
5547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5548   void * jresult ;
5549   Dali::Vector2 *arg1 = 0 ;
5550   float *arg2 = 0 ;
5551   float *arg3 = 0 ;
5552   float temp2 ;
5553   float temp3 ;
5554   Dali::Vector2 result;
5555
5556   arg1 = (Dali::Vector2 *)jarg1;
5557   if (!arg1) {
5558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5559     return 0;
5560   }
5561   temp2 = (float)jarg2;
5562   arg2 = &temp2;
5563   temp3 = (float)jarg3;
5564   arg3 = &temp3;
5565   {
5566     try {
5567       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5568     } catch (std::out_of_range& e) {
5569       {
5570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5571       };
5572     } catch (std::exception& e) {
5573       {
5574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5575       };
5576     } catch (Dali::DaliException e) {
5577       {
5578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5579       };
5580     } catch (...) {
5581       {
5582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5583       };
5584     }
5585   }
5586
5587   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5588   return jresult;
5589 }
5590
5591
5592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5593   void * jresult ;
5594   Dali::Vector3 *result = 0 ;
5595
5596   {
5597     try {
5598       result = (Dali::Vector3 *)new Dali::Vector3();
5599     } catch (std::out_of_range& e) {
5600       {
5601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5602       };
5603     } catch (std::exception& e) {
5604       {
5605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5606       };
5607     } catch (Dali::DaliException e) {
5608       {
5609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5610       };
5611     } catch (...) {
5612       {
5613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5614       };
5615     }
5616   }
5617
5618   jresult = (void *)result;
5619   return jresult;
5620 }
5621
5622
5623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5624   void * jresult ;
5625   float arg1 ;
5626   float arg2 ;
5627   float arg3 ;
5628   Dali::Vector3 *result = 0 ;
5629
5630   arg1 = (float)jarg1;
5631   arg2 = (float)jarg2;
5632   arg3 = (float)jarg3;
5633   {
5634     try {
5635       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5636     } catch (std::out_of_range& e) {
5637       {
5638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5639       };
5640     } catch (std::exception& e) {
5641       {
5642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5643       };
5644     } catch (Dali::DaliException e) {
5645       {
5646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5647       };
5648     } catch (...) {
5649       {
5650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5651       };
5652     }
5653   }
5654
5655   jresult = (void *)result;
5656   return jresult;
5657 }
5658
5659
5660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5661   void * jresult ;
5662   float *arg1 = (float *) 0 ;
5663   Dali::Vector3 *result = 0 ;
5664
5665   arg1 = jarg1;
5666   {
5667     try {
5668       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5669     } catch (std::out_of_range& e) {
5670       {
5671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5672       };
5673     } catch (std::exception& e) {
5674       {
5675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5676       };
5677     } catch (Dali::DaliException e) {
5678       {
5679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5680       };
5681     } catch (...) {
5682       {
5683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5684       };
5685     }
5686   }
5687
5688   jresult = (void *)result;
5689
5690
5691   return jresult;
5692 }
5693
5694
5695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5696   void * jresult ;
5697   Dali::Vector2 *arg1 = 0 ;
5698   Dali::Vector3 *result = 0 ;
5699
5700   arg1 = (Dali::Vector2 *)jarg1;
5701   if (!arg1) {
5702     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5703     return 0;
5704   }
5705   {
5706     try {
5707       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5708     } catch (std::out_of_range& e) {
5709       {
5710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5711       };
5712     } catch (std::exception& e) {
5713       {
5714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5715       };
5716     } catch (Dali::DaliException e) {
5717       {
5718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5719       };
5720     } catch (...) {
5721       {
5722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5723       };
5724     }
5725   }
5726
5727   jresult = (void *)result;
5728   return jresult;
5729 }
5730
5731
5732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5733   void * jresult ;
5734   Dali::Vector4 *arg1 = 0 ;
5735   Dali::Vector3 *result = 0 ;
5736
5737   arg1 = (Dali::Vector4 *)jarg1;
5738   if (!arg1) {
5739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5740     return 0;
5741   }
5742   {
5743     try {
5744       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5745     } catch (std::out_of_range& e) {
5746       {
5747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5748       };
5749     } catch (std::exception& e) {
5750       {
5751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5752       };
5753     } catch (Dali::DaliException e) {
5754       {
5755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5756       };
5757     } catch (...) {
5758       {
5759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5760       };
5761     }
5762   }
5763
5764   jresult = (void *)result;
5765   return jresult;
5766 }
5767
5768
5769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5770   void * jresult ;
5771   Dali::Vector3 *result = 0 ;
5772
5773   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5774   jresult = (void *)result;
5775   return jresult;
5776 }
5777
5778
5779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5780   void * jresult ;
5781   Dali::Vector3 *result = 0 ;
5782
5783   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5784   jresult = (void *)result;
5785   return jresult;
5786 }
5787
5788
5789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5790   void * jresult ;
5791   Dali::Vector3 *result = 0 ;
5792
5793   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5794   jresult = (void *)result;
5795   return jresult;
5796 }
5797
5798
5799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5800   void * jresult ;
5801   Dali::Vector3 *result = 0 ;
5802
5803   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5804   jresult = (void *)result;
5805   return jresult;
5806 }
5807
5808
5809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5810   void * jresult ;
5811   Dali::Vector3 *result = 0 ;
5812
5813   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5814   jresult = (void *)result;
5815   return jresult;
5816 }
5817
5818
5819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5820   void * jresult ;
5821   Dali::Vector3 *result = 0 ;
5822
5823   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5824   jresult = (void *)result;
5825   return jresult;
5826 }
5827
5828
5829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5830   void * jresult ;
5831   Dali::Vector3 *result = 0 ;
5832
5833   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5834   jresult = (void *)result;
5835   return jresult;
5836 }
5837
5838
5839 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5840   void * jresult ;
5841   Dali::Vector3 *result = 0 ;
5842
5843   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5844   jresult = (void *)result;
5845   return jresult;
5846 }
5847
5848
5849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5850   void * jresult ;
5851   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5852   float *arg2 = (float *) 0 ;
5853   Dali::Vector3 *result = 0 ;
5854
5855   arg1 = (Dali::Vector3 *)jarg1;
5856   arg2 = jarg2;
5857   {
5858     try {
5859       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5860     } catch (std::out_of_range& e) {
5861       {
5862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5863       };
5864     } catch (std::exception& e) {
5865       {
5866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5867       };
5868     } catch (Dali::DaliException e) {
5869       {
5870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5871       };
5872     } catch (...) {
5873       {
5874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5875       };
5876     }
5877   }
5878
5879   jresult = (void *)result;
5880
5881
5882   return jresult;
5883 }
5884
5885
5886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5887   void * jresult ;
5888   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5889   Dali::Vector2 *arg2 = 0 ;
5890   Dali::Vector3 *result = 0 ;
5891
5892   arg1 = (Dali::Vector3 *)jarg1;
5893   arg2 = (Dali::Vector2 *)jarg2;
5894   if (!arg2) {
5895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5896     return 0;
5897   }
5898   {
5899     try {
5900       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5901     } catch (std::out_of_range& e) {
5902       {
5903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5904       };
5905     } catch (std::exception& e) {
5906       {
5907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5908       };
5909     } catch (Dali::DaliException e) {
5910       {
5911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5912       };
5913     } catch (...) {
5914       {
5915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5916       };
5917     }
5918   }
5919
5920   jresult = (void *)result;
5921   return jresult;
5922 }
5923
5924
5925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5926   void * jresult ;
5927   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5928   Dali::Vector4 *arg2 = 0 ;
5929   Dali::Vector3 *result = 0 ;
5930
5931   arg1 = (Dali::Vector3 *)jarg1;
5932   arg2 = (Dali::Vector4 *)jarg2;
5933   if (!arg2) {
5934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5935     return 0;
5936   }
5937   {
5938     try {
5939       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5940     } catch (std::out_of_range& e) {
5941       {
5942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5943       };
5944     } catch (std::exception& e) {
5945       {
5946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5947       };
5948     } catch (Dali::DaliException e) {
5949       {
5950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5951       };
5952     } catch (...) {
5953       {
5954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5955       };
5956     }
5957   }
5958
5959   jresult = (void *)result;
5960   return jresult;
5961 }
5962
5963
5964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5965   void * jresult ;
5966   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5967   Dali::Vector3 *arg2 = 0 ;
5968   Dali::Vector3 result;
5969
5970   arg1 = (Dali::Vector3 *)jarg1;
5971   arg2 = (Dali::Vector3 *)jarg2;
5972   if (!arg2) {
5973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5974     return 0;
5975   }
5976   {
5977     try {
5978       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5979     } catch (std::out_of_range& e) {
5980       {
5981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5982       };
5983     } catch (std::exception& e) {
5984       {
5985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5986       };
5987     } catch (Dali::DaliException e) {
5988       {
5989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5990       };
5991     } catch (...) {
5992       {
5993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5994       };
5995     }
5996   }
5997
5998   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5999   return jresult;
6000 }
6001
6002
6003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
6004   void * jresult ;
6005   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6006   Dali::Vector3 *arg2 = 0 ;
6007   Dali::Vector3 *result = 0 ;
6008
6009   arg1 = (Dali::Vector3 *)jarg1;
6010   arg2 = (Dali::Vector3 *)jarg2;
6011   if (!arg2) {
6012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6013     return 0;
6014   }
6015   {
6016     try {
6017       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
6018     } catch (std::out_of_range& e) {
6019       {
6020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6021       };
6022     } catch (std::exception& e) {
6023       {
6024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6025       };
6026     } catch (Dali::DaliException e) {
6027       {
6028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6029       };
6030     } catch (...) {
6031       {
6032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6033       };
6034     }
6035   }
6036
6037   jresult = (void *)result;
6038   return jresult;
6039 }
6040
6041
6042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
6043   void * jresult ;
6044   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6045   Dali::Vector3 *arg2 = 0 ;
6046   Dali::Vector3 result;
6047
6048   arg1 = (Dali::Vector3 *)jarg1;
6049   arg2 = (Dali::Vector3 *)jarg2;
6050   if (!arg2) {
6051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6052     return 0;
6053   }
6054   {
6055     try {
6056       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6057     } catch (std::out_of_range& e) {
6058       {
6059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6060       };
6061     } catch (std::exception& e) {
6062       {
6063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6064       };
6065     } catch (Dali::DaliException e) {
6066       {
6067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6068       };
6069     } catch (...) {
6070       {
6071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6072       };
6073     }
6074   }
6075
6076   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6077   return jresult;
6078 }
6079
6080
6081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6082   void * jresult ;
6083   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6084   Dali::Vector3 *arg2 = 0 ;
6085   Dali::Vector3 *result = 0 ;
6086
6087   arg1 = (Dali::Vector3 *)jarg1;
6088   arg2 = (Dali::Vector3 *)jarg2;
6089   if (!arg2) {
6090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6091     return 0;
6092   }
6093   {
6094     try {
6095       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6096     } catch (std::out_of_range& e) {
6097       {
6098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6099       };
6100     } catch (std::exception& e) {
6101       {
6102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6103       };
6104     } catch (Dali::DaliException e) {
6105       {
6106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6107       };
6108     } catch (...) {
6109       {
6110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6111       };
6112     }
6113   }
6114
6115   jresult = (void *)result;
6116   return jresult;
6117 }
6118
6119
6120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6121   void * jresult ;
6122   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6123   Dali::Vector3 *arg2 = 0 ;
6124   Dali::Vector3 result;
6125
6126   arg1 = (Dali::Vector3 *)jarg1;
6127   arg2 = (Dali::Vector3 *)jarg2;
6128   if (!arg2) {
6129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6130     return 0;
6131   }
6132   {
6133     try {
6134       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6135     } catch (std::out_of_range& e) {
6136       {
6137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6138       };
6139     } catch (std::exception& e) {
6140       {
6141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6142       };
6143     } catch (Dali::DaliException e) {
6144       {
6145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6146       };
6147     } catch (...) {
6148       {
6149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6150       };
6151     }
6152   }
6153
6154   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6155   return jresult;
6156 }
6157
6158
6159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6160   void * jresult ;
6161   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6162   float arg2 ;
6163   Dali::Vector3 result;
6164
6165   arg1 = (Dali::Vector3 *)jarg1;
6166   arg2 = (float)jarg2;
6167   {
6168     try {
6169       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6170     } catch (std::out_of_range& e) {
6171       {
6172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6173       };
6174     } catch (std::exception& e) {
6175       {
6176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6177       };
6178     } catch (Dali::DaliException e) {
6179       {
6180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6181       };
6182     } catch (...) {
6183       {
6184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6185       };
6186     }
6187   }
6188
6189   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6190   return jresult;
6191 }
6192
6193
6194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6195   void * jresult ;
6196   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6197   Dali::Vector3 *arg2 = 0 ;
6198   Dali::Vector3 *result = 0 ;
6199
6200   arg1 = (Dali::Vector3 *)jarg1;
6201   arg2 = (Dali::Vector3 *)jarg2;
6202   if (!arg2) {
6203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6204     return 0;
6205   }
6206   {
6207     try {
6208       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6209     } catch (std::out_of_range& e) {
6210       {
6211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6212       };
6213     } catch (std::exception& e) {
6214       {
6215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6216       };
6217     } catch (Dali::DaliException e) {
6218       {
6219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6220       };
6221     } catch (...) {
6222       {
6223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6224       };
6225     }
6226   }
6227
6228   jresult = (void *)result;
6229   return jresult;
6230 }
6231
6232
6233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6234   void * jresult ;
6235   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6236   float arg2 ;
6237   Dali::Vector3 *result = 0 ;
6238
6239   arg1 = (Dali::Vector3 *)jarg1;
6240   arg2 = (float)jarg2;
6241   {
6242     try {
6243       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6244     } catch (std::out_of_range& e) {
6245       {
6246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6247       };
6248     } catch (std::exception& e) {
6249       {
6250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6251       };
6252     } catch (Dali::DaliException e) {
6253       {
6254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6255       };
6256     } catch (...) {
6257       {
6258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6259       };
6260     }
6261   }
6262
6263   jresult = (void *)result;
6264   return jresult;
6265 }
6266
6267
6268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6269   void * jresult ;
6270   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6271   Dali::Quaternion *arg2 = 0 ;
6272   Dali::Vector3 *result = 0 ;
6273
6274   arg1 = (Dali::Vector3 *)jarg1;
6275   arg2 = (Dali::Quaternion *)jarg2;
6276   if (!arg2) {
6277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6278     return 0;
6279   }
6280   {
6281     try {
6282       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6283     } catch (std::out_of_range& e) {
6284       {
6285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6286       };
6287     } catch (std::exception& e) {
6288       {
6289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6290       };
6291     } catch (Dali::DaliException e) {
6292       {
6293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6294       };
6295     } catch (...) {
6296       {
6297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6298       };
6299     }
6300   }
6301
6302   jresult = (void *)result;
6303   return jresult;
6304 }
6305
6306
6307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6308   void * jresult ;
6309   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6310   Dali::Vector3 *arg2 = 0 ;
6311   Dali::Vector3 result;
6312
6313   arg1 = (Dali::Vector3 *)jarg1;
6314   arg2 = (Dali::Vector3 *)jarg2;
6315   if (!arg2) {
6316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6317     return 0;
6318   }
6319   {
6320     try {
6321       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6322     } catch (std::out_of_range& e) {
6323       {
6324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6325       };
6326     } catch (std::exception& e) {
6327       {
6328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6329       };
6330     } catch (Dali::DaliException e) {
6331       {
6332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6333       };
6334     } catch (...) {
6335       {
6336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6337       };
6338     }
6339   }
6340
6341   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6342   return jresult;
6343 }
6344
6345
6346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6347   void * jresult ;
6348   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6349   float arg2 ;
6350   Dali::Vector3 result;
6351
6352   arg1 = (Dali::Vector3 *)jarg1;
6353   arg2 = (float)jarg2;
6354   {
6355     try {
6356       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6357     } catch (std::out_of_range& e) {
6358       {
6359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6360       };
6361     } catch (std::exception& e) {
6362       {
6363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6364       };
6365     } catch (Dali::DaliException e) {
6366       {
6367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6368       };
6369     } catch (...) {
6370       {
6371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6372       };
6373     }
6374   }
6375
6376   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6377   return jresult;
6378 }
6379
6380
6381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6382   void * jresult ;
6383   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6384   Dali::Vector3 *arg2 = 0 ;
6385   Dali::Vector3 *result = 0 ;
6386
6387   arg1 = (Dali::Vector3 *)jarg1;
6388   arg2 = (Dali::Vector3 *)jarg2;
6389   if (!arg2) {
6390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6391     return 0;
6392   }
6393   {
6394     try {
6395       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6396     } catch (std::out_of_range& e) {
6397       {
6398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6399       };
6400     } catch (std::exception& e) {
6401       {
6402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6403       };
6404     } catch (Dali::DaliException e) {
6405       {
6406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6407       };
6408     } catch (...) {
6409       {
6410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6411       };
6412     }
6413   }
6414
6415   jresult = (void *)result;
6416   return jresult;
6417 }
6418
6419
6420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6421   void * jresult ;
6422   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6423   float arg2 ;
6424   Dali::Vector3 *result = 0 ;
6425
6426   arg1 = (Dali::Vector3 *)jarg1;
6427   arg2 = (float)jarg2;
6428   {
6429     try {
6430       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6431     } catch (std::out_of_range& e) {
6432       {
6433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6434       };
6435     } catch (std::exception& e) {
6436       {
6437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6438       };
6439     } catch (Dali::DaliException e) {
6440       {
6441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6442       };
6443     } catch (...) {
6444       {
6445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6446       };
6447     }
6448   }
6449
6450   jresult = (void *)result;
6451   return jresult;
6452 }
6453
6454
6455 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6456   void * jresult ;
6457   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6458   Dali::Vector3 result;
6459
6460   arg1 = (Dali::Vector3 *)jarg1;
6461   {
6462     try {
6463       result = ((Dali::Vector3 const *)arg1)->operator -();
6464     } catch (std::out_of_range& e) {
6465       {
6466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6467       };
6468     } catch (std::exception& e) {
6469       {
6470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6471       };
6472     } catch (Dali::DaliException e) {
6473       {
6474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6475       };
6476     } catch (...) {
6477       {
6478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6479       };
6480     }
6481   }
6482
6483   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6484   return jresult;
6485 }
6486
6487
6488 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6489   unsigned int jresult ;
6490   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6491   Dali::Vector3 *arg2 = 0 ;
6492   bool result;
6493
6494   arg1 = (Dali::Vector3 *)jarg1;
6495   arg2 = (Dali::Vector3 *)jarg2;
6496   if (!arg2) {
6497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6498     return 0;
6499   }
6500   {
6501     try {
6502       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6503     } catch (std::out_of_range& e) {
6504       {
6505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6506       };
6507     } catch (std::exception& e) {
6508       {
6509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6510       };
6511     } catch (Dali::DaliException e) {
6512       {
6513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6514       };
6515     } catch (...) {
6516       {
6517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6518       };
6519     }
6520   }
6521
6522   jresult = result;
6523   return jresult;
6524 }
6525
6526
6527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6528   unsigned int jresult ;
6529   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6530   Dali::Vector3 *arg2 = 0 ;
6531   bool result;
6532
6533   arg1 = (Dali::Vector3 *)jarg1;
6534   arg2 = (Dali::Vector3 *)jarg2;
6535   if (!arg2) {
6536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6537     return 0;
6538   }
6539   {
6540     try {
6541       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6542     } catch (std::out_of_range& e) {
6543       {
6544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6545       };
6546     } catch (std::exception& e) {
6547       {
6548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6549       };
6550     } catch (Dali::DaliException e) {
6551       {
6552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6553       };
6554     } catch (...) {
6555       {
6556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6557       };
6558     }
6559   }
6560
6561   jresult = result;
6562   return jresult;
6563 }
6564
6565
6566 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6567   float jresult ;
6568   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6569   unsigned int arg2 ;
6570   float *result = 0 ;
6571
6572   arg1 = (Dali::Vector3 *)jarg1;
6573   arg2 = (unsigned int)jarg2;
6574   {
6575     try {
6576       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6577     } catch (std::out_of_range& e) {
6578       {
6579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6580       };
6581     } catch (std::exception& e) {
6582       {
6583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6584       };
6585     } catch (Dali::DaliException e) {
6586       {
6587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6588       };
6589     } catch (...) {
6590       {
6591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6592       };
6593     }
6594   }
6595
6596   jresult = *result;
6597   return jresult;
6598 }
6599
6600
6601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6602   float jresult ;
6603   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6604   Dali::Vector3 *arg2 = 0 ;
6605   float result;
6606
6607   arg1 = (Dali::Vector3 *)jarg1;
6608   arg2 = (Dali::Vector3 *)jarg2;
6609   if (!arg2) {
6610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6611     return 0;
6612   }
6613   {
6614     try {
6615       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6616     } catch (std::out_of_range& e) {
6617       {
6618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6619       };
6620     } catch (std::exception& e) {
6621       {
6622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6623       };
6624     } catch (Dali::DaliException e) {
6625       {
6626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6627       };
6628     } catch (...) {
6629       {
6630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6631       };
6632     }
6633   }
6634
6635   jresult = result;
6636   return jresult;
6637 }
6638
6639
6640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6641   void * jresult ;
6642   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6643   Dali::Vector3 *arg2 = 0 ;
6644   Dali::Vector3 result;
6645
6646   arg1 = (Dali::Vector3 *)jarg1;
6647   arg2 = (Dali::Vector3 *)jarg2;
6648   if (!arg2) {
6649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6650     return 0;
6651   }
6652   {
6653     try {
6654       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6655     } catch (std::out_of_range& e) {
6656       {
6657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6658       };
6659     } catch (std::exception& e) {
6660       {
6661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6662       };
6663     } catch (Dali::DaliException e) {
6664       {
6665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6666       };
6667     } catch (...) {
6668       {
6669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6670       };
6671     }
6672   }
6673
6674   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6675   return jresult;
6676 }
6677
6678
6679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6680   float jresult ;
6681   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6682   float result;
6683
6684   arg1 = (Dali::Vector3 *)jarg1;
6685   {
6686     try {
6687       result = (float)((Dali::Vector3 const *)arg1)->Length();
6688     } catch (std::out_of_range& e) {
6689       {
6690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6691       };
6692     } catch (std::exception& e) {
6693       {
6694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6695       };
6696     } catch (Dali::DaliException e) {
6697       {
6698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6699       };
6700     } catch (...) {
6701       {
6702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6703       };
6704     }
6705   }
6706
6707   jresult = result;
6708   return jresult;
6709 }
6710
6711
6712 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6713   float jresult ;
6714   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6715   float result;
6716
6717   arg1 = (Dali::Vector3 *)jarg1;
6718   {
6719     try {
6720       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6721     } catch (std::out_of_range& e) {
6722       {
6723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6724       };
6725     } catch (std::exception& e) {
6726       {
6727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6728       };
6729     } catch (Dali::DaliException e) {
6730       {
6731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6732       };
6733     } catch (...) {
6734       {
6735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6736       };
6737     }
6738   }
6739
6740   jresult = result;
6741   return jresult;
6742 }
6743
6744
6745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6746   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6747
6748   arg1 = (Dali::Vector3 *)jarg1;
6749   {
6750     try {
6751       (arg1)->Normalize();
6752     } catch (std::out_of_range& e) {
6753       {
6754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6755       };
6756     } catch (std::exception& e) {
6757       {
6758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6759       };
6760     } catch (Dali::DaliException e) {
6761       {
6762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6763       };
6764     } catch (...) {
6765       {
6766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6767       };
6768     }
6769   }
6770
6771 }
6772
6773
6774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6775   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6776   Dali::Vector3 *arg2 = 0 ;
6777   Dali::Vector3 *arg3 = 0 ;
6778
6779   arg1 = (Dali::Vector3 *)jarg1;
6780   arg2 = (Dali::Vector3 *)jarg2;
6781   if (!arg2) {
6782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6783     return ;
6784   }
6785   arg3 = (Dali::Vector3 *)jarg3;
6786   if (!arg3) {
6787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6788     return ;
6789   }
6790   {
6791     try {
6792       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6793     } catch (std::out_of_range& e) {
6794       {
6795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6796       };
6797     } catch (std::exception& e) {
6798       {
6799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6800       };
6801     } catch (Dali::DaliException e) {
6802       {
6803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6804       };
6805     } catch (...) {
6806       {
6807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6808       };
6809     }
6810   }
6811
6812 }
6813
6814
6815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6816   void * jresult ;
6817   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6818   float *result = 0 ;
6819
6820   arg1 = (Dali::Vector3 *)jarg1;
6821   {
6822     try {
6823       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6824     } catch (std::out_of_range& e) {
6825       {
6826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6827       };
6828     } catch (std::exception& e) {
6829       {
6830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6831       };
6832     } catch (Dali::DaliException e) {
6833       {
6834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6835       };
6836     } catch (...) {
6837       {
6838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6839       };
6840     }
6841   }
6842
6843   jresult = (void *)result;
6844   return jresult;
6845 }
6846
6847
6848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6849   void * jresult ;
6850   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6851   Dali::Vector2 *result = 0 ;
6852
6853   arg1 = (Dali::Vector3 *)jarg1;
6854   {
6855     try {
6856       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6857     } catch (std::out_of_range& e) {
6858       {
6859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6860       };
6861     } catch (std::exception& e) {
6862       {
6863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6864       };
6865     } catch (Dali::DaliException e) {
6866       {
6867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6868       };
6869     } catch (...) {
6870       {
6871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6872       };
6873     }
6874   }
6875
6876   jresult = (void *)result;
6877   return jresult;
6878 }
6879
6880
6881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6882   void * jresult ;
6883   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6884   Dali::Vector2 *result = 0 ;
6885
6886   arg1 = (Dali::Vector3 *)jarg1;
6887   {
6888     try {
6889       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6890     } catch (std::out_of_range& e) {
6891       {
6892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6893       };
6894     } catch (std::exception& e) {
6895       {
6896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6897       };
6898     } catch (Dali::DaliException e) {
6899       {
6900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6901       };
6902     } catch (...) {
6903       {
6904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6905       };
6906     }
6907   }
6908
6909   jresult = (void *)result;
6910   return jresult;
6911 }
6912
6913
6914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6915   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6916   float arg2 ;
6917
6918   arg1 = (Dali::Vector3 *)jarg1;
6919   arg2 = (float)jarg2;
6920   if (arg1) (arg1)->x = arg2;
6921 }
6922
6923
6924 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6925   float jresult ;
6926   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6927   float result;
6928
6929   arg1 = (Dali::Vector3 *)jarg1;
6930   result = (float) ((arg1)->x);
6931   jresult = result;
6932   return jresult;
6933 }
6934
6935
6936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6937   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6938   float arg2 ;
6939
6940   arg1 = (Dali::Vector3 *)jarg1;
6941   arg2 = (float)jarg2;
6942   if (arg1) (arg1)->width = arg2;
6943 }
6944
6945
6946 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6947   float jresult ;
6948   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6949   float result;
6950
6951   arg1 = (Dali::Vector3 *)jarg1;
6952   result = (float) ((arg1)->width);
6953   jresult = result;
6954   return jresult;
6955 }
6956
6957
6958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6959   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6960   float arg2 ;
6961
6962   arg1 = (Dali::Vector3 *)jarg1;
6963   arg2 = (float)jarg2;
6964   if (arg1) (arg1)->r = arg2;
6965 }
6966
6967
6968 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6969   float jresult ;
6970   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6971   float result;
6972
6973   arg1 = (Dali::Vector3 *)jarg1;
6974   result = (float) ((arg1)->r);
6975   jresult = result;
6976   return jresult;
6977 }
6978
6979
6980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6981   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6982   float arg2 ;
6983
6984   arg1 = (Dali::Vector3 *)jarg1;
6985   arg2 = (float)jarg2;
6986   if (arg1) (arg1)->y = arg2;
6987 }
6988
6989
6990 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6991   float jresult ;
6992   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6993   float result;
6994
6995   arg1 = (Dali::Vector3 *)jarg1;
6996   result = (float) ((arg1)->y);
6997   jresult = result;
6998   return jresult;
6999 }
7000
7001
7002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
7003   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7004   float arg2 ;
7005
7006   arg1 = (Dali::Vector3 *)jarg1;
7007   arg2 = (float)jarg2;
7008   if (arg1) (arg1)->height = arg2;
7009 }
7010
7011
7012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
7013   float jresult ;
7014   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7015   float result;
7016
7017   arg1 = (Dali::Vector3 *)jarg1;
7018   result = (float) ((arg1)->height);
7019   jresult = result;
7020   return jresult;
7021 }
7022
7023
7024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
7025   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7026   float arg2 ;
7027
7028   arg1 = (Dali::Vector3 *)jarg1;
7029   arg2 = (float)jarg2;
7030   if (arg1) (arg1)->g = arg2;
7031 }
7032
7033
7034 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
7035   float jresult ;
7036   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7037   float result;
7038
7039   arg1 = (Dali::Vector3 *)jarg1;
7040   result = (float) ((arg1)->g);
7041   jresult = result;
7042   return jresult;
7043 }
7044
7045
7046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
7047   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7048   float arg2 ;
7049
7050   arg1 = (Dali::Vector3 *)jarg1;
7051   arg2 = (float)jarg2;
7052   if (arg1) (arg1)->z = arg2;
7053 }
7054
7055
7056 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7057   float jresult ;
7058   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7059   float result;
7060
7061   arg1 = (Dali::Vector3 *)jarg1;
7062   result = (float) ((arg1)->z);
7063   jresult = result;
7064   return jresult;
7065 }
7066
7067
7068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7069   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7070   float arg2 ;
7071
7072   arg1 = (Dali::Vector3 *)jarg1;
7073   arg2 = (float)jarg2;
7074   if (arg1) (arg1)->depth = arg2;
7075 }
7076
7077
7078 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7079   float jresult ;
7080   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7081   float result;
7082
7083   arg1 = (Dali::Vector3 *)jarg1;
7084   result = (float) ((arg1)->depth);
7085   jresult = result;
7086   return jresult;
7087 }
7088
7089
7090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7091   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7092   float arg2 ;
7093
7094   arg1 = (Dali::Vector3 *)jarg1;
7095   arg2 = (float)jarg2;
7096   if (arg1) (arg1)->b = arg2;
7097 }
7098
7099
7100 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7101   float jresult ;
7102   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7103   float result;
7104
7105   arg1 = (Dali::Vector3 *)jarg1;
7106   result = (float) ((arg1)->b);
7107   jresult = result;
7108   return jresult;
7109 }
7110
7111
7112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7113   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7114
7115   arg1 = (Dali::Vector3 *)jarg1;
7116   {
7117     try {
7118       delete arg1;
7119     } catch (std::out_of_range& e) {
7120       {
7121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7122       };
7123     } catch (std::exception& e) {
7124       {
7125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7126       };
7127     } catch (Dali::DaliException e) {
7128       {
7129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7130       };
7131     } catch (...) {
7132       {
7133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7134       };
7135     }
7136   }
7137
7138 }
7139
7140
7141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7142   void * jresult ;
7143   Dali::Vector3 *arg1 = 0 ;
7144   Dali::Vector3 *arg2 = 0 ;
7145   Dali::Vector3 result;
7146
7147   arg1 = (Dali::Vector3 *)jarg1;
7148   if (!arg1) {
7149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7150     return 0;
7151   }
7152   arg2 = (Dali::Vector3 *)jarg2;
7153   if (!arg2) {
7154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7155     return 0;
7156   }
7157   {
7158     try {
7159       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7160     } catch (std::out_of_range& e) {
7161       {
7162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7163       };
7164     } catch (std::exception& e) {
7165       {
7166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7167       };
7168     } catch (Dali::DaliException e) {
7169       {
7170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7171       };
7172     } catch (...) {
7173       {
7174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7175       };
7176     }
7177   }
7178
7179   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7180   return jresult;
7181 }
7182
7183
7184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7185   void * jresult ;
7186   Dali::Vector3 *arg1 = 0 ;
7187   Dali::Vector3 *arg2 = 0 ;
7188   Dali::Vector3 result;
7189
7190   arg1 = (Dali::Vector3 *)jarg1;
7191   if (!arg1) {
7192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7193     return 0;
7194   }
7195   arg2 = (Dali::Vector3 *)jarg2;
7196   if (!arg2) {
7197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7198     return 0;
7199   }
7200   {
7201     try {
7202       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7203     } catch (std::out_of_range& e) {
7204       {
7205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7206       };
7207     } catch (std::exception& e) {
7208       {
7209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7210       };
7211     } catch (Dali::DaliException e) {
7212       {
7213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7214       };
7215     } catch (...) {
7216       {
7217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7218       };
7219     }
7220   }
7221
7222   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7223   return jresult;
7224 }
7225
7226
7227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7228   void * jresult ;
7229   Dali::Vector3 *arg1 = 0 ;
7230   float *arg2 = 0 ;
7231   float *arg3 = 0 ;
7232   float temp2 ;
7233   float temp3 ;
7234   Dali::Vector3 result;
7235
7236   arg1 = (Dali::Vector3 *)jarg1;
7237   if (!arg1) {
7238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7239     return 0;
7240   }
7241   temp2 = (float)jarg2;
7242   arg2 = &temp2;
7243   temp3 = (float)jarg3;
7244   arg3 = &temp3;
7245   {
7246     try {
7247       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7248     } catch (std::out_of_range& e) {
7249       {
7250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7251       };
7252     } catch (std::exception& e) {
7253       {
7254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7255       };
7256     } catch (Dali::DaliException e) {
7257       {
7258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7259       };
7260     } catch (...) {
7261       {
7262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7263       };
7264     }
7265   }
7266
7267   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7268   return jresult;
7269 }
7270
7271
7272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7273   void * jresult ;
7274   Dali::Vector4 *result = 0 ;
7275
7276   {
7277     try {
7278       result = (Dali::Vector4 *)new Dali::Vector4();
7279     } catch (std::out_of_range& e) {
7280       {
7281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7282       };
7283     } catch (std::exception& e) {
7284       {
7285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7286       };
7287     } catch (Dali::DaliException e) {
7288       {
7289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7290       };
7291     } catch (...) {
7292       {
7293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7294       };
7295     }
7296   }
7297
7298   jresult = (void *)result;
7299   return jresult;
7300 }
7301
7302
7303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7304   void * jresult ;
7305   float arg1 ;
7306   float arg2 ;
7307   float arg3 ;
7308   float arg4 ;
7309   Dali::Vector4 *result = 0 ;
7310
7311   arg1 = (float)jarg1;
7312   arg2 = (float)jarg2;
7313   arg3 = (float)jarg3;
7314   arg4 = (float)jarg4;
7315   {
7316     try {
7317       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7318     } catch (std::out_of_range& e) {
7319       {
7320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7321       };
7322     } catch (std::exception& e) {
7323       {
7324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7325       };
7326     } catch (Dali::DaliException e) {
7327       {
7328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7329       };
7330     } catch (...) {
7331       {
7332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7333       };
7334     }
7335   }
7336
7337   jresult = (void *)result;
7338   return jresult;
7339 }
7340
7341
7342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7343   void * jresult ;
7344   float *arg1 = (float *) 0 ;
7345   Dali::Vector4 *result = 0 ;
7346
7347   arg1 = jarg1;
7348   {
7349     try {
7350       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7351     } catch (std::out_of_range& e) {
7352       {
7353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7354       };
7355     } catch (std::exception& e) {
7356       {
7357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7358       };
7359     } catch (Dali::DaliException e) {
7360       {
7361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7362       };
7363     } catch (...) {
7364       {
7365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7366       };
7367     }
7368   }
7369
7370   jresult = (void *)result;
7371
7372
7373   return jresult;
7374 }
7375
7376
7377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7378   void * jresult ;
7379   Dali::Vector2 *arg1 = 0 ;
7380   Dali::Vector4 *result = 0 ;
7381
7382   arg1 = (Dali::Vector2 *)jarg1;
7383   if (!arg1) {
7384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7385     return 0;
7386   }
7387   {
7388     try {
7389       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7390     } catch (std::out_of_range& e) {
7391       {
7392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7393       };
7394     } catch (std::exception& e) {
7395       {
7396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7397       };
7398     } catch (Dali::DaliException e) {
7399       {
7400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7401       };
7402     } catch (...) {
7403       {
7404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7405       };
7406     }
7407   }
7408
7409   jresult = (void *)result;
7410   return jresult;
7411 }
7412
7413
7414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7415   void * jresult ;
7416   Dali::Vector3 *arg1 = 0 ;
7417   Dali::Vector4 *result = 0 ;
7418
7419   arg1 = (Dali::Vector3 *)jarg1;
7420   if (!arg1) {
7421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7422     return 0;
7423   }
7424   {
7425     try {
7426       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7427     } catch (std::out_of_range& e) {
7428       {
7429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7430       };
7431     } catch (std::exception& e) {
7432       {
7433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7434       };
7435     } catch (Dali::DaliException e) {
7436       {
7437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7438       };
7439     } catch (...) {
7440       {
7441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7442       };
7443     }
7444   }
7445
7446   jresult = (void *)result;
7447   return jresult;
7448 }
7449
7450
7451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7452   void * jresult ;
7453   Dali::Vector4 *result = 0 ;
7454
7455   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7456   jresult = (void *)result;
7457   return jresult;
7458 }
7459
7460
7461 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7462   void * jresult ;
7463   Dali::Vector4 *result = 0 ;
7464
7465   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7466   jresult = (void *)result;
7467   return jresult;
7468 }
7469
7470
7471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7472   void * jresult ;
7473   Dali::Vector4 *result = 0 ;
7474
7475   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7476   jresult = (void *)result;
7477   return jresult;
7478 }
7479
7480
7481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7482   void * jresult ;
7483   Dali::Vector4 *result = 0 ;
7484
7485   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7486   jresult = (void *)result;
7487   return jresult;
7488 }
7489
7490
7491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7492   void * jresult ;
7493   Dali::Vector4 *result = 0 ;
7494
7495   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7496   jresult = (void *)result;
7497   return jresult;
7498 }
7499
7500
7501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7502   void * jresult ;
7503   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7504   float *arg2 = (float *) 0 ;
7505   Dali::Vector4 *result = 0 ;
7506
7507   arg1 = (Dali::Vector4 *)jarg1;
7508   arg2 = jarg2;
7509   {
7510     try {
7511       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7512     } catch (std::out_of_range& e) {
7513       {
7514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7515       };
7516     } catch (std::exception& e) {
7517       {
7518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7519       };
7520     } catch (Dali::DaliException e) {
7521       {
7522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7523       };
7524     } catch (...) {
7525       {
7526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7527       };
7528     }
7529   }
7530
7531   jresult = (void *)result;
7532
7533
7534   return jresult;
7535 }
7536
7537
7538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7539   void * jresult ;
7540   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7541   Dali::Vector2 *arg2 = 0 ;
7542   Dali::Vector4 *result = 0 ;
7543
7544   arg1 = (Dali::Vector4 *)jarg1;
7545   arg2 = (Dali::Vector2 *)jarg2;
7546   if (!arg2) {
7547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7548     return 0;
7549   }
7550   {
7551     try {
7552       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7553     } catch (std::out_of_range& e) {
7554       {
7555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7556       };
7557     } catch (std::exception& e) {
7558       {
7559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7560       };
7561     } catch (Dali::DaliException e) {
7562       {
7563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7564       };
7565     } catch (...) {
7566       {
7567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7568       };
7569     }
7570   }
7571
7572   jresult = (void *)result;
7573   return jresult;
7574 }
7575
7576
7577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7578   void * jresult ;
7579   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7580   Dali::Vector3 *arg2 = 0 ;
7581   Dali::Vector4 *result = 0 ;
7582
7583   arg1 = (Dali::Vector4 *)jarg1;
7584   arg2 = (Dali::Vector3 *)jarg2;
7585   if (!arg2) {
7586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7587     return 0;
7588   }
7589   {
7590     try {
7591       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7592     } catch (std::out_of_range& e) {
7593       {
7594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7595       };
7596     } catch (std::exception& e) {
7597       {
7598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7599       };
7600     } catch (Dali::DaliException e) {
7601       {
7602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7603       };
7604     } catch (...) {
7605       {
7606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7607       };
7608     }
7609   }
7610
7611   jresult = (void *)result;
7612   return jresult;
7613 }
7614
7615
7616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7617   void * jresult ;
7618   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7619   Dali::Vector4 *arg2 = 0 ;
7620   Dali::Vector4 result;
7621
7622   arg1 = (Dali::Vector4 *)jarg1;
7623   arg2 = (Dali::Vector4 *)jarg2;
7624   if (!arg2) {
7625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7626     return 0;
7627   }
7628   {
7629     try {
7630       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7631     } catch (std::out_of_range& e) {
7632       {
7633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7634       };
7635     } catch (std::exception& e) {
7636       {
7637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7638       };
7639     } catch (Dali::DaliException e) {
7640       {
7641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7642       };
7643     } catch (...) {
7644       {
7645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7646       };
7647     }
7648   }
7649
7650   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7651   return jresult;
7652 }
7653
7654
7655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7656   void * jresult ;
7657   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7658   Dali::Vector4 *arg2 = 0 ;
7659   Dali::Vector4 *result = 0 ;
7660
7661   arg1 = (Dali::Vector4 *)jarg1;
7662   arg2 = (Dali::Vector4 *)jarg2;
7663   if (!arg2) {
7664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7665     return 0;
7666   }
7667   {
7668     try {
7669       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7670     } catch (std::out_of_range& e) {
7671       {
7672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7673       };
7674     } catch (std::exception& e) {
7675       {
7676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7677       };
7678     } catch (Dali::DaliException e) {
7679       {
7680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7681       };
7682     } catch (...) {
7683       {
7684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7685       };
7686     }
7687   }
7688
7689   jresult = (void *)result;
7690   return jresult;
7691 }
7692
7693
7694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7695   void * jresult ;
7696   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7697   Dali::Vector4 *arg2 = 0 ;
7698   Dali::Vector4 result;
7699
7700   arg1 = (Dali::Vector4 *)jarg1;
7701   arg2 = (Dali::Vector4 *)jarg2;
7702   if (!arg2) {
7703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7704     return 0;
7705   }
7706   {
7707     try {
7708       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7709     } catch (std::out_of_range& e) {
7710       {
7711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7712       };
7713     } catch (std::exception& e) {
7714       {
7715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7716       };
7717     } catch (Dali::DaliException e) {
7718       {
7719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7720       };
7721     } catch (...) {
7722       {
7723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7724       };
7725     }
7726   }
7727
7728   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7729   return jresult;
7730 }
7731
7732
7733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7734   void * jresult ;
7735   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7736   Dali::Vector4 *arg2 = 0 ;
7737   Dali::Vector4 *result = 0 ;
7738
7739   arg1 = (Dali::Vector4 *)jarg1;
7740   arg2 = (Dali::Vector4 *)jarg2;
7741   if (!arg2) {
7742     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7743     return 0;
7744   }
7745   {
7746     try {
7747       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7748     } catch (std::out_of_range& e) {
7749       {
7750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7751       };
7752     } catch (std::exception& e) {
7753       {
7754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7755       };
7756     } catch (Dali::DaliException e) {
7757       {
7758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7759       };
7760     } catch (...) {
7761       {
7762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7763       };
7764     }
7765   }
7766
7767   jresult = (void *)result;
7768   return jresult;
7769 }
7770
7771
7772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7773   void * jresult ;
7774   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7775   Dali::Vector4 *arg2 = 0 ;
7776   Dali::Vector4 result;
7777
7778   arg1 = (Dali::Vector4 *)jarg1;
7779   arg2 = (Dali::Vector4 *)jarg2;
7780   if (!arg2) {
7781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7782     return 0;
7783   }
7784   {
7785     try {
7786       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7787     } catch (std::out_of_range& e) {
7788       {
7789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7790       };
7791     } catch (std::exception& e) {
7792       {
7793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7794       };
7795     } catch (Dali::DaliException e) {
7796       {
7797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7798       };
7799     } catch (...) {
7800       {
7801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7802       };
7803     }
7804   }
7805
7806   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7807   return jresult;
7808 }
7809
7810
7811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7812   void * jresult ;
7813   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7814   float arg2 ;
7815   Dali::Vector4 result;
7816
7817   arg1 = (Dali::Vector4 *)jarg1;
7818   arg2 = (float)jarg2;
7819   {
7820     try {
7821       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7822     } catch (std::out_of_range& e) {
7823       {
7824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7825       };
7826     } catch (std::exception& e) {
7827       {
7828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7829       };
7830     } catch (Dali::DaliException e) {
7831       {
7832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7833       };
7834     } catch (...) {
7835       {
7836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7837       };
7838     }
7839   }
7840
7841   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7842   return jresult;
7843 }
7844
7845
7846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7847   void * jresult ;
7848   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7849   Dali::Vector4 *arg2 = 0 ;
7850   Dali::Vector4 *result = 0 ;
7851
7852   arg1 = (Dali::Vector4 *)jarg1;
7853   arg2 = (Dali::Vector4 *)jarg2;
7854   if (!arg2) {
7855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7856     return 0;
7857   }
7858   {
7859     try {
7860       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7861     } catch (std::out_of_range& e) {
7862       {
7863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7864       };
7865     } catch (std::exception& e) {
7866       {
7867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7868       };
7869     } catch (Dali::DaliException e) {
7870       {
7871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7872       };
7873     } catch (...) {
7874       {
7875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7876       };
7877     }
7878   }
7879
7880   jresult = (void *)result;
7881   return jresult;
7882 }
7883
7884
7885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7886   void * jresult ;
7887   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7888   float arg2 ;
7889   Dali::Vector4 *result = 0 ;
7890
7891   arg1 = (Dali::Vector4 *)jarg1;
7892   arg2 = (float)jarg2;
7893   {
7894     try {
7895       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7896     } catch (std::out_of_range& e) {
7897       {
7898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7899       };
7900     } catch (std::exception& e) {
7901       {
7902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7903       };
7904     } catch (Dali::DaliException e) {
7905       {
7906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7907       };
7908     } catch (...) {
7909       {
7910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7911       };
7912     }
7913   }
7914
7915   jresult = (void *)result;
7916   return jresult;
7917 }
7918
7919
7920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7921   void * jresult ;
7922   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7923   Dali::Vector4 *arg2 = 0 ;
7924   Dali::Vector4 result;
7925
7926   arg1 = (Dali::Vector4 *)jarg1;
7927   arg2 = (Dali::Vector4 *)jarg2;
7928   if (!arg2) {
7929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7930     return 0;
7931   }
7932   {
7933     try {
7934       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7935     } catch (std::out_of_range& e) {
7936       {
7937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7938       };
7939     } catch (std::exception& e) {
7940       {
7941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7942       };
7943     } catch (Dali::DaliException e) {
7944       {
7945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7946       };
7947     } catch (...) {
7948       {
7949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7950       };
7951     }
7952   }
7953
7954   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7955   return jresult;
7956 }
7957
7958
7959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7960   void * jresult ;
7961   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7962   float arg2 ;
7963   Dali::Vector4 result;
7964
7965   arg1 = (Dali::Vector4 *)jarg1;
7966   arg2 = (float)jarg2;
7967   {
7968     try {
7969       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7970     } catch (std::out_of_range& e) {
7971       {
7972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7973       };
7974     } catch (std::exception& e) {
7975       {
7976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7977       };
7978     } catch (Dali::DaliException e) {
7979       {
7980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7981       };
7982     } catch (...) {
7983       {
7984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7985       };
7986     }
7987   }
7988
7989   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7990   return jresult;
7991 }
7992
7993
7994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7995   void * jresult ;
7996   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7997   Dali::Vector4 *arg2 = 0 ;
7998   Dali::Vector4 *result = 0 ;
7999
8000   arg1 = (Dali::Vector4 *)jarg1;
8001   arg2 = (Dali::Vector4 *)jarg2;
8002   if (!arg2) {
8003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8004     return 0;
8005   }
8006   {
8007     try {
8008       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
8009     } catch (std::out_of_range& e) {
8010       {
8011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8012       };
8013     } catch (std::exception& e) {
8014       {
8015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8016       };
8017     } catch (Dali::DaliException e) {
8018       {
8019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8020       };
8021     } catch (...) {
8022       {
8023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8024       };
8025     }
8026   }
8027
8028   jresult = (void *)result;
8029   return jresult;
8030 }
8031
8032
8033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
8034   void * jresult ;
8035   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8036   float arg2 ;
8037   Dali::Vector4 *result = 0 ;
8038
8039   arg1 = (Dali::Vector4 *)jarg1;
8040   arg2 = (float)jarg2;
8041   {
8042     try {
8043       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
8044     } catch (std::out_of_range& e) {
8045       {
8046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8047       };
8048     } catch (std::exception& e) {
8049       {
8050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8051       };
8052     } catch (Dali::DaliException e) {
8053       {
8054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8055       };
8056     } catch (...) {
8057       {
8058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8059       };
8060     }
8061   }
8062
8063   jresult = (void *)result;
8064   return jresult;
8065 }
8066
8067
8068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8069   void * jresult ;
8070   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8071   Dali::Vector4 result;
8072
8073   arg1 = (Dali::Vector4 *)jarg1;
8074   {
8075     try {
8076       result = ((Dali::Vector4 const *)arg1)->operator -();
8077     } catch (std::out_of_range& e) {
8078       {
8079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8080       };
8081     } catch (std::exception& e) {
8082       {
8083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8084       };
8085     } catch (Dali::DaliException e) {
8086       {
8087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8088       };
8089     } catch (...) {
8090       {
8091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8092       };
8093     }
8094   }
8095
8096   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8097   return jresult;
8098 }
8099
8100
8101 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8102   unsigned int jresult ;
8103   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8104   Dali::Vector4 *arg2 = 0 ;
8105   bool result;
8106
8107   arg1 = (Dali::Vector4 *)jarg1;
8108   arg2 = (Dali::Vector4 *)jarg2;
8109   if (!arg2) {
8110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8111     return 0;
8112   }
8113   {
8114     try {
8115       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8116     } catch (std::out_of_range& e) {
8117       {
8118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8119       };
8120     } catch (std::exception& e) {
8121       {
8122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8123       };
8124     } catch (Dali::DaliException e) {
8125       {
8126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8127       };
8128     } catch (...) {
8129       {
8130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8131       };
8132     }
8133   }
8134
8135   jresult = result;
8136   return jresult;
8137 }
8138
8139
8140 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8141   unsigned int jresult ;
8142   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8143   Dali::Vector4 *arg2 = 0 ;
8144   bool result;
8145
8146   arg1 = (Dali::Vector4 *)jarg1;
8147   arg2 = (Dali::Vector4 *)jarg2;
8148   if (!arg2) {
8149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8150     return 0;
8151   }
8152   {
8153     try {
8154       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8155     } catch (std::out_of_range& e) {
8156       {
8157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8158       };
8159     } catch (std::exception& e) {
8160       {
8161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8162       };
8163     } catch (Dali::DaliException e) {
8164       {
8165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8166       };
8167     } catch (...) {
8168       {
8169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8170       };
8171     }
8172   }
8173
8174   jresult = result;
8175   return jresult;
8176 }
8177
8178
8179 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8180   float jresult ;
8181   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8182   unsigned int arg2 ;
8183   float *result = 0 ;
8184
8185   arg1 = (Dali::Vector4 *)jarg1;
8186   arg2 = (unsigned int)jarg2;
8187   {
8188     try {
8189       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8190     } catch (std::out_of_range& e) {
8191       {
8192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8193       };
8194     } catch (std::exception& e) {
8195       {
8196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8197       };
8198     } catch (Dali::DaliException e) {
8199       {
8200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8201       };
8202     } catch (...) {
8203       {
8204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8205       };
8206     }
8207   }
8208
8209   jresult = *result;
8210   return jresult;
8211 }
8212
8213
8214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8215   float jresult ;
8216   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8217   Dali::Vector3 *arg2 = 0 ;
8218   float result;
8219
8220   arg1 = (Dali::Vector4 *)jarg1;
8221   arg2 = (Dali::Vector3 *)jarg2;
8222   if (!arg2) {
8223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8224     return 0;
8225   }
8226   {
8227     try {
8228       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8229     } catch (std::out_of_range& e) {
8230       {
8231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8232       };
8233     } catch (std::exception& e) {
8234       {
8235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8236       };
8237     } catch (Dali::DaliException e) {
8238       {
8239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8240       };
8241     } catch (...) {
8242       {
8243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8244       };
8245     }
8246   }
8247
8248   jresult = result;
8249   return jresult;
8250 }
8251
8252
8253 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8254   float jresult ;
8255   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8256   Dali::Vector4 *arg2 = 0 ;
8257   float result;
8258
8259   arg1 = (Dali::Vector4 *)jarg1;
8260   arg2 = (Dali::Vector4 *)jarg2;
8261   if (!arg2) {
8262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8263     return 0;
8264   }
8265   {
8266     try {
8267       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8268     } catch (std::out_of_range& e) {
8269       {
8270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8271       };
8272     } catch (std::exception& e) {
8273       {
8274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8275       };
8276     } catch (Dali::DaliException e) {
8277       {
8278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8279       };
8280     } catch (...) {
8281       {
8282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8283       };
8284     }
8285   }
8286
8287   jresult = result;
8288   return jresult;
8289 }
8290
8291
8292 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8293   float jresult ;
8294   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8295   Dali::Vector4 *arg2 = 0 ;
8296   float result;
8297
8298   arg1 = (Dali::Vector4 *)jarg1;
8299   arg2 = (Dali::Vector4 *)jarg2;
8300   if (!arg2) {
8301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8302     return 0;
8303   }
8304   {
8305     try {
8306       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8307     } catch (std::out_of_range& e) {
8308       {
8309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8310       };
8311     } catch (std::exception& e) {
8312       {
8313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8314       };
8315     } catch (Dali::DaliException e) {
8316       {
8317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8318       };
8319     } catch (...) {
8320       {
8321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8322       };
8323     }
8324   }
8325
8326   jresult = result;
8327   return jresult;
8328 }
8329
8330
8331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8332   void * jresult ;
8333   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8334   Dali::Vector4 *arg2 = 0 ;
8335   Dali::Vector4 result;
8336
8337   arg1 = (Dali::Vector4 *)jarg1;
8338   arg2 = (Dali::Vector4 *)jarg2;
8339   if (!arg2) {
8340     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8341     return 0;
8342   }
8343   {
8344     try {
8345       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8346     } catch (std::out_of_range& e) {
8347       {
8348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8349       };
8350     } catch (std::exception& e) {
8351       {
8352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8353       };
8354     } catch (Dali::DaliException e) {
8355       {
8356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8357       };
8358     } catch (...) {
8359       {
8360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8361       };
8362     }
8363   }
8364
8365   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8366   return jresult;
8367 }
8368
8369
8370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8371   float jresult ;
8372   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8373   float result;
8374
8375   arg1 = (Dali::Vector4 *)jarg1;
8376   {
8377     try {
8378       result = (float)((Dali::Vector4 const *)arg1)->Length();
8379     } catch (std::out_of_range& e) {
8380       {
8381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8382       };
8383     } catch (std::exception& e) {
8384       {
8385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8386       };
8387     } catch (Dali::DaliException e) {
8388       {
8389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8390       };
8391     } catch (...) {
8392       {
8393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8394       };
8395     }
8396   }
8397
8398   jresult = result;
8399   return jresult;
8400 }
8401
8402
8403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8404   float jresult ;
8405   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8406   float result;
8407
8408   arg1 = (Dali::Vector4 *)jarg1;
8409   {
8410     try {
8411       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8412     } catch (std::out_of_range& e) {
8413       {
8414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8415       };
8416     } catch (std::exception& e) {
8417       {
8418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8419       };
8420     } catch (Dali::DaliException e) {
8421       {
8422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8423       };
8424     } catch (...) {
8425       {
8426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8427       };
8428     }
8429   }
8430
8431   jresult = result;
8432   return jresult;
8433 }
8434
8435
8436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8437   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8438
8439   arg1 = (Dali::Vector4 *)jarg1;
8440   {
8441     try {
8442       (arg1)->Normalize();
8443     } catch (std::out_of_range& e) {
8444       {
8445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8446       };
8447     } catch (std::exception& e) {
8448       {
8449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8450       };
8451     } catch (Dali::DaliException e) {
8452       {
8453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8454       };
8455     } catch (...) {
8456       {
8457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8458       };
8459     }
8460   }
8461
8462 }
8463
8464
8465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8466   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8467   Dali::Vector4 *arg2 = 0 ;
8468   Dali::Vector4 *arg3 = 0 ;
8469
8470   arg1 = (Dali::Vector4 *)jarg1;
8471   arg2 = (Dali::Vector4 *)jarg2;
8472   if (!arg2) {
8473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8474     return ;
8475   }
8476   arg3 = (Dali::Vector4 *)jarg3;
8477   if (!arg3) {
8478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8479     return ;
8480   }
8481   {
8482     try {
8483       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8484     } catch (std::out_of_range& e) {
8485       {
8486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8487       };
8488     } catch (std::exception& e) {
8489       {
8490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8491       };
8492     } catch (Dali::DaliException e) {
8493       {
8494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8495       };
8496     } catch (...) {
8497       {
8498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8499       };
8500     }
8501   }
8502
8503 }
8504
8505
8506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8507   void * jresult ;
8508   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8509   float *result = 0 ;
8510
8511   arg1 = (Dali::Vector4 *)jarg1;
8512   {
8513     try {
8514       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8515     } catch (std::out_of_range& e) {
8516       {
8517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8518       };
8519     } catch (std::exception& e) {
8520       {
8521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8522       };
8523     } catch (Dali::DaliException e) {
8524       {
8525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8526       };
8527     } catch (...) {
8528       {
8529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8530       };
8531     }
8532   }
8533
8534   jresult = (void *)result;
8535   return jresult;
8536 }
8537
8538
8539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8540   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8541   float arg2 ;
8542
8543   arg1 = (Dali::Vector4 *)jarg1;
8544   arg2 = (float)jarg2;
8545   if (arg1) (arg1)->x = arg2;
8546 }
8547
8548
8549 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8550   float jresult ;
8551   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8552   float result;
8553
8554   arg1 = (Dali::Vector4 *)jarg1;
8555   result = (float) ((arg1)->x);
8556   jresult = result;
8557   return jresult;
8558 }
8559
8560
8561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8562   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8563   float arg2 ;
8564
8565   arg1 = (Dali::Vector4 *)jarg1;
8566   arg2 = (float)jarg2;
8567   if (arg1) (arg1)->r = arg2;
8568 }
8569
8570
8571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8572   float jresult ;
8573   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8574   float result;
8575
8576   arg1 = (Dali::Vector4 *)jarg1;
8577   result = (float) ((arg1)->r);
8578   jresult = result;
8579   return jresult;
8580 }
8581
8582
8583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8584   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8585   float arg2 ;
8586
8587   arg1 = (Dali::Vector4 *)jarg1;
8588   arg2 = (float)jarg2;
8589   if (arg1) (arg1)->s = arg2;
8590 }
8591
8592
8593 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8594   float jresult ;
8595   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8596   float result;
8597
8598   arg1 = (Dali::Vector4 *)jarg1;
8599   result = (float) ((arg1)->s);
8600   jresult = result;
8601   return jresult;
8602 }
8603
8604
8605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8606   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8607   float arg2 ;
8608
8609   arg1 = (Dali::Vector4 *)jarg1;
8610   arg2 = (float)jarg2;
8611   if (arg1) (arg1)->y = arg2;
8612 }
8613
8614
8615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8616   float jresult ;
8617   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8618   float result;
8619
8620   arg1 = (Dali::Vector4 *)jarg1;
8621   result = (float) ((arg1)->y);
8622   jresult = result;
8623   return jresult;
8624 }
8625
8626
8627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8628   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8629   float arg2 ;
8630
8631   arg1 = (Dali::Vector4 *)jarg1;
8632   arg2 = (float)jarg2;
8633   if (arg1) (arg1)->g = arg2;
8634 }
8635
8636
8637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8638   float jresult ;
8639   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8640   float result;
8641
8642   arg1 = (Dali::Vector4 *)jarg1;
8643   result = (float) ((arg1)->g);
8644   jresult = result;
8645   return jresult;
8646 }
8647
8648
8649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8650   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8651   float arg2 ;
8652
8653   arg1 = (Dali::Vector4 *)jarg1;
8654   arg2 = (float)jarg2;
8655   if (arg1) (arg1)->t = arg2;
8656 }
8657
8658
8659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8660   float jresult ;
8661   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8662   float result;
8663
8664   arg1 = (Dali::Vector4 *)jarg1;
8665   result = (float) ((arg1)->t);
8666   jresult = result;
8667   return jresult;
8668 }
8669
8670
8671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8672   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8673   float arg2 ;
8674
8675   arg1 = (Dali::Vector4 *)jarg1;
8676   arg2 = (float)jarg2;
8677   if (arg1) (arg1)->z = arg2;
8678 }
8679
8680
8681 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8682   float jresult ;
8683   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8684   float result;
8685
8686   arg1 = (Dali::Vector4 *)jarg1;
8687   result = (float) ((arg1)->z);
8688   jresult = result;
8689   return jresult;
8690 }
8691
8692
8693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8694   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8695   float arg2 ;
8696
8697   arg1 = (Dali::Vector4 *)jarg1;
8698   arg2 = (float)jarg2;
8699   if (arg1) (arg1)->b = arg2;
8700 }
8701
8702
8703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8704   float jresult ;
8705   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8706   float result;
8707
8708   arg1 = (Dali::Vector4 *)jarg1;
8709   result = (float) ((arg1)->b);
8710   jresult = result;
8711   return jresult;
8712 }
8713
8714
8715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8716   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8717   float arg2 ;
8718
8719   arg1 = (Dali::Vector4 *)jarg1;
8720   arg2 = (float)jarg2;
8721   if (arg1) (arg1)->p = arg2;
8722 }
8723
8724
8725 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8726   float jresult ;
8727   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8728   float result;
8729
8730   arg1 = (Dali::Vector4 *)jarg1;
8731   result = (float) ((arg1)->p);
8732   jresult = result;
8733   return jresult;
8734 }
8735
8736
8737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8738   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8739   float arg2 ;
8740
8741   arg1 = (Dali::Vector4 *)jarg1;
8742   arg2 = (float)jarg2;
8743   if (arg1) (arg1)->w = arg2;
8744 }
8745
8746
8747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8748   float jresult ;
8749   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8750   float result;
8751
8752   arg1 = (Dali::Vector4 *)jarg1;
8753   result = (float) ((arg1)->w);
8754   jresult = result;
8755   return jresult;
8756 }
8757
8758
8759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8760   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8761   float arg2 ;
8762
8763   arg1 = (Dali::Vector4 *)jarg1;
8764   arg2 = (float)jarg2;
8765   if (arg1) (arg1)->a = arg2;
8766 }
8767
8768
8769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8770   float jresult ;
8771   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8772   float result;
8773
8774   arg1 = (Dali::Vector4 *)jarg1;
8775   result = (float) ((arg1)->a);
8776   jresult = result;
8777   return jresult;
8778 }
8779
8780
8781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8782   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8783   float arg2 ;
8784
8785   arg1 = (Dali::Vector4 *)jarg1;
8786   arg2 = (float)jarg2;
8787   if (arg1) (arg1)->q = arg2;
8788 }
8789
8790
8791 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8792   float jresult ;
8793   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8794   float result;
8795
8796   arg1 = (Dali::Vector4 *)jarg1;
8797   result = (float) ((arg1)->q);
8798   jresult = result;
8799   return jresult;
8800 }
8801
8802
8803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8804   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8805
8806   arg1 = (Dali::Vector4 *)jarg1;
8807   {
8808     try {
8809       delete arg1;
8810     } catch (std::out_of_range& e) {
8811       {
8812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8813       };
8814     } catch (std::exception& e) {
8815       {
8816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8817       };
8818     } catch (Dali::DaliException e) {
8819       {
8820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8821       };
8822     } catch (...) {
8823       {
8824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8825       };
8826     }
8827   }
8828
8829 }
8830
8831
8832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8833   void * jresult ;
8834   Dali::Vector4 *arg1 = 0 ;
8835   Dali::Vector4 *arg2 = 0 ;
8836   Dali::Vector4 result;
8837
8838   arg1 = (Dali::Vector4 *)jarg1;
8839   if (!arg1) {
8840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8841     return 0;
8842   }
8843   arg2 = (Dali::Vector4 *)jarg2;
8844   if (!arg2) {
8845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8846     return 0;
8847   }
8848   {
8849     try {
8850       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8851     } catch (std::out_of_range& e) {
8852       {
8853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8854       };
8855     } catch (std::exception& e) {
8856       {
8857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8858       };
8859     } catch (Dali::DaliException e) {
8860       {
8861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8862       };
8863     } catch (...) {
8864       {
8865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8866       };
8867     }
8868   }
8869
8870   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8871   return jresult;
8872 }
8873
8874
8875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8876   void * jresult ;
8877   Dali::Vector4 *arg1 = 0 ;
8878   Dali::Vector4 *arg2 = 0 ;
8879   Dali::Vector4 result;
8880
8881   arg1 = (Dali::Vector4 *)jarg1;
8882   if (!arg1) {
8883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8884     return 0;
8885   }
8886   arg2 = (Dali::Vector4 *)jarg2;
8887   if (!arg2) {
8888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8889     return 0;
8890   }
8891   {
8892     try {
8893       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8894     } catch (std::out_of_range& e) {
8895       {
8896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8897       };
8898     } catch (std::exception& e) {
8899       {
8900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8901       };
8902     } catch (Dali::DaliException e) {
8903       {
8904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8905       };
8906     } catch (...) {
8907       {
8908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8909       };
8910     }
8911   }
8912
8913   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8914   return jresult;
8915 }
8916
8917
8918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8919   void * jresult ;
8920   Dali::Vector4 *arg1 = 0 ;
8921   float *arg2 = 0 ;
8922   float *arg3 = 0 ;
8923   float temp2 ;
8924   float temp3 ;
8925   Dali::Vector4 result;
8926
8927   arg1 = (Dali::Vector4 *)jarg1;
8928   if (!arg1) {
8929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8930     return 0;
8931   }
8932   temp2 = (float)jarg2;
8933   arg2 = &temp2;
8934   temp3 = (float)jarg3;
8935   arg3 = &temp3;
8936   {
8937     try {
8938       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8939     } catch (std::out_of_range& e) {
8940       {
8941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8942       };
8943     } catch (std::exception& e) {
8944       {
8945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8946       };
8947     } catch (Dali::DaliException e) {
8948       {
8949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8950       };
8951     } catch (...) {
8952       {
8953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8954       };
8955     }
8956   }
8957
8958   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8959   return jresult;
8960 }
8961
8962
8963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8964   void * jresult ;
8965   Dali::Uint16Pair *result = 0 ;
8966
8967   {
8968     try {
8969       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8970     } catch (std::out_of_range& e) {
8971       {
8972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8973       };
8974     } catch (std::exception& e) {
8975       {
8976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8977       };
8978     } catch (Dali::DaliException e) {
8979       {
8980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8981       };
8982     } catch (...) {
8983       {
8984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8985       };
8986     }
8987   }
8988
8989   jresult = (void *)result;
8990   return jresult;
8991 }
8992
8993
8994 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8995   void * jresult ;
8996   uint32_t arg1 ;
8997   uint32_t arg2 ;
8998   Dali::Uint16Pair *result = 0 ;
8999
9000   arg1 = (uint32_t)jarg1;
9001   arg2 = (uint32_t)jarg2;
9002   {
9003     try {
9004       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
9005     } catch (std::out_of_range& e) {
9006       {
9007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9008       };
9009     } catch (std::exception& e) {
9010       {
9011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9012       };
9013     } catch (Dali::DaliException e) {
9014       {
9015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9016       };
9017     } catch (...) {
9018       {
9019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9020       };
9021     }
9022   }
9023
9024   jresult = (void *)result;
9025   return jresult;
9026 }
9027
9028
9029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
9030   void * jresult ;
9031   Dali::Uint16Pair *arg1 = 0 ;
9032   Dali::Uint16Pair *result = 0 ;
9033
9034   arg1 = (Dali::Uint16Pair *)jarg1;
9035   if (!arg1) {
9036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9037     return 0;
9038   }
9039   {
9040     try {
9041       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
9042     } catch (std::out_of_range& e) {
9043       {
9044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9045       };
9046     } catch (std::exception& e) {
9047       {
9048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9049       };
9050     } catch (Dali::DaliException e) {
9051       {
9052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9053       };
9054     } catch (...) {
9055       {
9056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9057       };
9058     }
9059   }
9060
9061   jresult = (void *)result;
9062   return jresult;
9063 }
9064
9065
9066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9067   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9068   uint16_t arg2 ;
9069
9070   arg1 = (Dali::Uint16Pair *)jarg1;
9071   arg2 = (uint16_t)jarg2;
9072   {
9073     try {
9074       (arg1)->SetWidth(arg2);
9075     } catch (std::out_of_range& e) {
9076       {
9077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9078       };
9079     } catch (std::exception& e) {
9080       {
9081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9082       };
9083     } catch (Dali::DaliException e) {
9084       {
9085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9086       };
9087     } catch (...) {
9088       {
9089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9090       };
9091     }
9092   }
9093
9094 }
9095
9096
9097 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9098   unsigned short jresult ;
9099   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9100   uint16_t result;
9101
9102   arg1 = (Dali::Uint16Pair *)jarg1;
9103   {
9104     try {
9105       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9106     } catch (std::out_of_range& e) {
9107       {
9108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9109       };
9110     } catch (std::exception& e) {
9111       {
9112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9113       };
9114     } catch (Dali::DaliException e) {
9115       {
9116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9117       };
9118     } catch (...) {
9119       {
9120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9121       };
9122     }
9123   }
9124
9125   jresult = result;
9126   return jresult;
9127 }
9128
9129
9130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9131   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9132   uint16_t arg2 ;
9133
9134   arg1 = (Dali::Uint16Pair *)jarg1;
9135   arg2 = (uint16_t)jarg2;
9136   {
9137     try {
9138       (arg1)->SetHeight(arg2);
9139     } catch (std::out_of_range& e) {
9140       {
9141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9142       };
9143     } catch (std::exception& e) {
9144       {
9145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9146       };
9147     } catch (Dali::DaliException e) {
9148       {
9149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9150       };
9151     } catch (...) {
9152       {
9153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9154       };
9155     }
9156   }
9157
9158 }
9159
9160
9161 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9162   unsigned short jresult ;
9163   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9164   uint16_t result;
9165
9166   arg1 = (Dali::Uint16Pair *)jarg1;
9167   {
9168     try {
9169       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9170     } catch (std::out_of_range& e) {
9171       {
9172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9173       };
9174     } catch (std::exception& e) {
9175       {
9176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9177       };
9178     } catch (Dali::DaliException e) {
9179       {
9180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9181       };
9182     } catch (...) {
9183       {
9184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9185       };
9186     }
9187   }
9188
9189   jresult = result;
9190   return jresult;
9191 }
9192
9193
9194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9195   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9196   uint16_t arg2 ;
9197
9198   arg1 = (Dali::Uint16Pair *)jarg1;
9199   arg2 = (uint16_t)jarg2;
9200   {
9201     try {
9202       (arg1)->SetX(arg2);
9203     } catch (std::out_of_range& e) {
9204       {
9205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9206       };
9207     } catch (std::exception& e) {
9208       {
9209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9210       };
9211     } catch (Dali::DaliException e) {
9212       {
9213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9214       };
9215     } catch (...) {
9216       {
9217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9218       };
9219     }
9220   }
9221
9222 }
9223
9224
9225 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9226   unsigned short jresult ;
9227   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9228   uint16_t result;
9229
9230   arg1 = (Dali::Uint16Pair *)jarg1;
9231   {
9232     try {
9233       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9234     } catch (std::out_of_range& e) {
9235       {
9236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9237       };
9238     } catch (std::exception& e) {
9239       {
9240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9241       };
9242     } catch (Dali::DaliException e) {
9243       {
9244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9245       };
9246     } catch (...) {
9247       {
9248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9249       };
9250     }
9251   }
9252
9253   jresult = result;
9254   return jresult;
9255 }
9256
9257
9258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9259   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9260   uint16_t arg2 ;
9261
9262   arg1 = (Dali::Uint16Pair *)jarg1;
9263   arg2 = (uint16_t)jarg2;
9264   {
9265     try {
9266       (arg1)->SetY(arg2);
9267     } catch (std::out_of_range& e) {
9268       {
9269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9270       };
9271     } catch (std::exception& e) {
9272       {
9273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9274       };
9275     } catch (Dali::DaliException e) {
9276       {
9277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9278       };
9279     } catch (...) {
9280       {
9281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9282       };
9283     }
9284   }
9285
9286 }
9287
9288
9289 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9290   unsigned short jresult ;
9291   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9292   uint16_t result;
9293
9294   arg1 = (Dali::Uint16Pair *)jarg1;
9295   {
9296     try {
9297       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9298     } catch (std::out_of_range& e) {
9299       {
9300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9301       };
9302     } catch (std::exception& e) {
9303       {
9304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9305       };
9306     } catch (Dali::DaliException e) {
9307       {
9308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9309       };
9310     } catch (...) {
9311       {
9312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9313       };
9314     }
9315   }
9316
9317   jresult = result;
9318   return jresult;
9319 }
9320
9321
9322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9323   void * jresult ;
9324   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9325   Dali::Uint16Pair *arg2 = 0 ;
9326   Dali::Uint16Pair *result = 0 ;
9327
9328   arg1 = (Dali::Uint16Pair *)jarg1;
9329   arg2 = (Dali::Uint16Pair *)jarg2;
9330   if (!arg2) {
9331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9332     return 0;
9333   }
9334   {
9335     try {
9336       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9337     } catch (std::out_of_range& e) {
9338       {
9339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9340       };
9341     } catch (std::exception& e) {
9342       {
9343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9344       };
9345     } catch (Dali::DaliException e) {
9346       {
9347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9348       };
9349     } catch (...) {
9350       {
9351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9352       };
9353     }
9354   }
9355
9356   jresult = (void *)result;
9357   return jresult;
9358 }
9359
9360
9361 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9362   unsigned int jresult ;
9363   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9364   Dali::Uint16Pair *arg2 = 0 ;
9365   bool result;
9366
9367   arg1 = (Dali::Uint16Pair *)jarg1;
9368   arg2 = (Dali::Uint16Pair *)jarg2;
9369   if (!arg2) {
9370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9371     return 0;
9372   }
9373   {
9374     try {
9375       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9376     } catch (std::out_of_range& e) {
9377       {
9378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9379       };
9380     } catch (std::exception& e) {
9381       {
9382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9383       };
9384     } catch (Dali::DaliException e) {
9385       {
9386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9387       };
9388     } catch (...) {
9389       {
9390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9391       };
9392     }
9393   }
9394
9395   jresult = result;
9396   return jresult;
9397 }
9398
9399
9400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9401   unsigned int jresult ;
9402   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9403   Dali::Uint16Pair *arg2 = 0 ;
9404   bool result;
9405
9406   arg1 = (Dali::Uint16Pair *)jarg1;
9407   arg2 = (Dali::Uint16Pair *)jarg2;
9408   if (!arg2) {
9409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9410     return 0;
9411   }
9412   {
9413     try {
9414       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9415     } catch (std::out_of_range& e) {
9416       {
9417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9418       };
9419     } catch (std::exception& e) {
9420       {
9421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9422       };
9423     } catch (Dali::DaliException e) {
9424       {
9425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9426       };
9427     } catch (...) {
9428       {
9429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9430       };
9431     }
9432   }
9433
9434   jresult = result;
9435   return jresult;
9436 }
9437
9438
9439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9440   unsigned int jresult ;
9441   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9442   Dali::Uint16Pair *arg2 = 0 ;
9443   bool result;
9444
9445   arg1 = (Dali::Uint16Pair *)jarg1;
9446   arg2 = (Dali::Uint16Pair *)jarg2;
9447   if (!arg2) {
9448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9449     return 0;
9450   }
9451   {
9452     try {
9453       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9454     } catch (std::out_of_range& e) {
9455       {
9456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9457       };
9458     } catch (std::exception& e) {
9459       {
9460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9461       };
9462     } catch (Dali::DaliException e) {
9463       {
9464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9465       };
9466     } catch (...) {
9467       {
9468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9469       };
9470     }
9471   }
9472
9473   jresult = result;
9474   return jresult;
9475 }
9476
9477
9478 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9479   unsigned int jresult ;
9480   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9481   Dali::Uint16Pair *arg2 = 0 ;
9482   bool result;
9483
9484   arg1 = (Dali::Uint16Pair *)jarg1;
9485   arg2 = (Dali::Uint16Pair *)jarg2;
9486   if (!arg2) {
9487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9488     return 0;
9489   }
9490   {
9491     try {
9492       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9493     } catch (std::out_of_range& e) {
9494       {
9495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9496       };
9497     } catch (std::exception& e) {
9498       {
9499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9500       };
9501     } catch (Dali::DaliException e) {
9502       {
9503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9504       };
9505     } catch (...) {
9506       {
9507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9508       };
9509     }
9510   }
9511
9512   jresult = result;
9513   return jresult;
9514 }
9515
9516
9517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9518   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9519
9520   arg1 = (Dali::Uint16Pair *)jarg1;
9521   {
9522     try {
9523       delete arg1;
9524     } catch (std::out_of_range& e) {
9525       {
9526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9527       };
9528     } catch (std::exception& e) {
9529       {
9530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9531       };
9532     } catch (Dali::DaliException e) {
9533       {
9534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9535       };
9536     } catch (...) {
9537       {
9538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9539       };
9540     }
9541   }
9542
9543 }
9544
9545
9546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9547   void * jresult ;
9548   Dali::Degree *result = 0 ;
9549
9550   {
9551     try {
9552       result = (Dali::Degree *)new Dali::Degree();
9553     } catch (std::out_of_range& e) {
9554       {
9555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9556       };
9557     } catch (std::exception& e) {
9558       {
9559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9560       };
9561     } catch (Dali::DaliException e) {
9562       {
9563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9564       };
9565     } catch (...) {
9566       {
9567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9568       };
9569     }
9570   }
9571
9572   jresult = (void *)result;
9573   return jresult;
9574 }
9575
9576
9577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9578   void * jresult ;
9579   float arg1 ;
9580   Dali::Degree *result = 0 ;
9581
9582   arg1 = (float)jarg1;
9583   {
9584     try {
9585       result = (Dali::Degree *)new Dali::Degree(arg1);
9586     } catch (std::out_of_range& e) {
9587       {
9588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9589       };
9590     } catch (std::exception& e) {
9591       {
9592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9593       };
9594     } catch (Dali::DaliException e) {
9595       {
9596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9597       };
9598     } catch (...) {
9599       {
9600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9601       };
9602     }
9603   }
9604
9605   jresult = (void *)result;
9606   return jresult;
9607 }
9608
9609
9610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9611   void * jresult ;
9612   Dali::Radian arg1 ;
9613   Dali::Radian *argp1 ;
9614   Dali::Degree *result = 0 ;
9615
9616   argp1 = (Dali::Radian *)jarg1;
9617   if (!argp1) {
9618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9619     return 0;
9620   }
9621   arg1 = *argp1;
9622   {
9623     try {
9624       result = (Dali::Degree *)new Dali::Degree(arg1);
9625     } catch (std::out_of_range& e) {
9626       {
9627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9628       };
9629     } catch (std::exception& e) {
9630       {
9631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9632       };
9633     } catch (Dali::DaliException e) {
9634       {
9635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9636       };
9637     } catch (...) {
9638       {
9639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9640       };
9641     }
9642   }
9643
9644   jresult = (void *)result;
9645   return jresult;
9646 }
9647
9648
9649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9650   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9651   float arg2 ;
9652
9653   arg1 = (Dali::Degree *)jarg1;
9654   arg2 = (float)jarg2;
9655   if (arg1) (arg1)->degree = arg2;
9656 }
9657
9658
9659 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9660   float jresult ;
9661   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9662   float result;
9663
9664   arg1 = (Dali::Degree *)jarg1;
9665   result = (float) ((arg1)->degree);
9666   jresult = result;
9667   return jresult;
9668 }
9669
9670
9671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9672   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9673
9674   arg1 = (Dali::Degree *)jarg1;
9675   {
9676     try {
9677       delete arg1;
9678     } catch (std::out_of_range& e) {
9679       {
9680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9681       };
9682     } catch (std::exception& e) {
9683       {
9684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9685       };
9686     } catch (Dali::DaliException e) {
9687       {
9688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9689       };
9690     } catch (...) {
9691       {
9692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9693       };
9694     }
9695   }
9696
9697 }
9698
9699
9700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9701   void * jresult ;
9702   Dali::Radian *result = 0 ;
9703
9704   result = (Dali::Radian *)&Dali::ANGLE_360;
9705   jresult = (void *)result;
9706   return jresult;
9707 }
9708
9709
9710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9711   void * jresult ;
9712   Dali::Radian *result = 0 ;
9713
9714   result = (Dali::Radian *)&Dali::ANGLE_315;
9715   jresult = (void *)result;
9716   return jresult;
9717 }
9718
9719
9720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9721   void * jresult ;
9722   Dali::Radian *result = 0 ;
9723
9724   result = (Dali::Radian *)&Dali::ANGLE_270;
9725   jresult = (void *)result;
9726   return jresult;
9727 }
9728
9729
9730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9731   void * jresult ;
9732   Dali::Radian *result = 0 ;
9733
9734   result = (Dali::Radian *)&Dali::ANGLE_225;
9735   jresult = (void *)result;
9736   return jresult;
9737 }
9738
9739
9740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9741   void * jresult ;
9742   Dali::Radian *result = 0 ;
9743
9744   result = (Dali::Radian *)&Dali::ANGLE_180;
9745   jresult = (void *)result;
9746   return jresult;
9747 }
9748
9749
9750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9751   void * jresult ;
9752   Dali::Radian *result = 0 ;
9753
9754   result = (Dali::Radian *)&Dali::ANGLE_135;
9755   jresult = (void *)result;
9756   return jresult;
9757 }
9758
9759
9760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9761   void * jresult ;
9762   Dali::Radian *result = 0 ;
9763
9764   result = (Dali::Radian *)&Dali::ANGLE_120;
9765   jresult = (void *)result;
9766   return jresult;
9767 }
9768
9769
9770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9771   void * jresult ;
9772   Dali::Radian *result = 0 ;
9773
9774   result = (Dali::Radian *)&Dali::ANGLE_90;
9775   jresult = (void *)result;
9776   return jresult;
9777 }
9778
9779
9780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9781   void * jresult ;
9782   Dali::Radian *result = 0 ;
9783
9784   result = (Dali::Radian *)&Dali::ANGLE_60;
9785   jresult = (void *)result;
9786   return jresult;
9787 }
9788
9789
9790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9791   void * jresult ;
9792   Dali::Radian *result = 0 ;
9793
9794   result = (Dali::Radian *)&Dali::ANGLE_45;
9795   jresult = (void *)result;
9796   return jresult;
9797 }
9798
9799
9800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9801   void * jresult ;
9802   Dali::Radian *result = 0 ;
9803
9804   result = (Dali::Radian *)&Dali::ANGLE_30;
9805   jresult = (void *)result;
9806   return jresult;
9807 }
9808
9809
9810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9811   void * jresult ;
9812   Dali::Radian *result = 0 ;
9813
9814   result = (Dali::Radian *)&Dali::ANGLE_0;
9815   jresult = (void *)result;
9816   return jresult;
9817 }
9818
9819
9820 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9821   unsigned int jresult ;
9822   Dali::Degree *arg1 = 0 ;
9823   Dali::Degree *arg2 = 0 ;
9824   bool result;
9825
9826   arg1 = (Dali::Degree *)jarg1;
9827   if (!arg1) {
9828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9829     return 0;
9830   }
9831   arg2 = (Dali::Degree *)jarg2;
9832   if (!arg2) {
9833     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9834     return 0;
9835   }
9836   {
9837     try {
9838       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9839     } catch (std::out_of_range& e) {
9840       {
9841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9842       };
9843     } catch (std::exception& e) {
9844       {
9845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9846       };
9847     } catch (Dali::DaliException e) {
9848       {
9849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9850       };
9851     } catch (...) {
9852       {
9853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9854       };
9855     }
9856   }
9857
9858   jresult = result;
9859   return jresult;
9860 }
9861
9862
9863 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9864   unsigned int jresult ;
9865   Dali::Degree *arg1 = 0 ;
9866   Dali::Degree *arg2 = 0 ;
9867   bool result;
9868
9869   arg1 = (Dali::Degree *)jarg1;
9870   if (!arg1) {
9871     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9872     return 0;
9873   }
9874   arg2 = (Dali::Degree *)jarg2;
9875   if (!arg2) {
9876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9877     return 0;
9878   }
9879   {
9880     try {
9881       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9882     } catch (std::out_of_range& e) {
9883       {
9884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9885       };
9886     } catch (std::exception& e) {
9887       {
9888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9889       };
9890     } catch (Dali::DaliException e) {
9891       {
9892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9893       };
9894     } catch (...) {
9895       {
9896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9897       };
9898     }
9899   }
9900
9901   jresult = result;
9902   return jresult;
9903 }
9904
9905
9906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9907   void * jresult ;
9908   Dali::Degree arg1 ;
9909   float arg2 ;
9910   float arg3 ;
9911   Dali::Degree *argp1 ;
9912   Dali::Degree result;
9913
9914   argp1 = (Dali::Degree *)jarg1;
9915   if (!argp1) {
9916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9917     return 0;
9918   }
9919   arg1 = *argp1;
9920   arg2 = (float)jarg2;
9921   arg3 = (float)jarg3;
9922   {
9923     try {
9924       result = Dali::Clamp(arg1,arg2,arg3);
9925     } catch (std::out_of_range& e) {
9926       {
9927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9928       };
9929     } catch (std::exception& e) {
9930       {
9931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9932       };
9933     } catch (Dali::DaliException e) {
9934       {
9935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9936       };
9937     } catch (...) {
9938       {
9939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9940       };
9941     }
9942   }
9943
9944   jresult = new Dali::Degree((const Dali::Degree &)result);
9945   return jresult;
9946 }
9947
9948
9949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9950   void * jresult ;
9951   Dali::Radian *result = 0 ;
9952
9953   {
9954     try {
9955       result = (Dali::Radian *)new Dali::Radian();
9956     } catch (std::out_of_range& e) {
9957       {
9958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9959       };
9960     } catch (std::exception& e) {
9961       {
9962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9963       };
9964     } catch (Dali::DaliException e) {
9965       {
9966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9967       };
9968     } catch (...) {
9969       {
9970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9971       };
9972     }
9973   }
9974
9975   jresult = (void *)result;
9976   return jresult;
9977 }
9978
9979
9980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9981   void * jresult ;
9982   float arg1 ;
9983   Dali::Radian *result = 0 ;
9984
9985   arg1 = (float)jarg1;
9986   {
9987     try {
9988       result = (Dali::Radian *)new Dali::Radian(arg1);
9989     } catch (std::out_of_range& e) {
9990       {
9991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9992       };
9993     } catch (std::exception& e) {
9994       {
9995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9996       };
9997     } catch (Dali::DaliException e) {
9998       {
9999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10000       };
10001     } catch (...) {
10002       {
10003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10004       };
10005     }
10006   }
10007
10008   jresult = (void *)result;
10009   return jresult;
10010 }
10011
10012
10013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
10014   void * jresult ;
10015   Dali::Degree arg1 ;
10016   Dali::Degree *argp1 ;
10017   Dali::Radian *result = 0 ;
10018
10019   argp1 = (Dali::Degree *)jarg1;
10020   if (!argp1) {
10021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10022     return 0;
10023   }
10024   arg1 = *argp1;
10025   {
10026     try {
10027       result = (Dali::Radian *)new Dali::Radian(arg1);
10028     } catch (std::out_of_range& e) {
10029       {
10030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10031       };
10032     } catch (std::exception& e) {
10033       {
10034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10035       };
10036     } catch (Dali::DaliException e) {
10037       {
10038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10039       };
10040     } catch (...) {
10041       {
10042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10043       };
10044     }
10045   }
10046
10047   jresult = (void *)result;
10048   return jresult;
10049 }
10050
10051
10052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
10053   void * jresult ;
10054   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10055   float arg2 ;
10056   Dali::Radian *result = 0 ;
10057
10058   arg1 = (Dali::Radian *)jarg1;
10059   arg2 = (float)jarg2;
10060   {
10061     try {
10062       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10063     } catch (std::out_of_range& e) {
10064       {
10065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10066       };
10067     } catch (std::exception& e) {
10068       {
10069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10070       };
10071     } catch (Dali::DaliException e) {
10072       {
10073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10074       };
10075     } catch (...) {
10076       {
10077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10078       };
10079     }
10080   }
10081
10082   jresult = (void *)result;
10083   return jresult;
10084 }
10085
10086
10087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10088   void * jresult ;
10089   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10090   Dali::Degree arg2 ;
10091   Dali::Degree *argp2 ;
10092   Dali::Radian *result = 0 ;
10093
10094   arg1 = (Dali::Radian *)jarg1;
10095   argp2 = (Dali::Degree *)jarg2;
10096   if (!argp2) {
10097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10098     return 0;
10099   }
10100   arg2 = *argp2;
10101   {
10102     try {
10103       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10104     } catch (std::out_of_range& e) {
10105       {
10106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10107       };
10108     } catch (std::exception& e) {
10109       {
10110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10111       };
10112     } catch (Dali::DaliException e) {
10113       {
10114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10115       };
10116     } catch (...) {
10117       {
10118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10119       };
10120     }
10121   }
10122
10123   jresult = (void *)result;
10124   return jresult;
10125 }
10126
10127
10128 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10129   float jresult ;
10130   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10131   float result;
10132
10133   arg1 = (Dali::Radian *)jarg1;
10134   {
10135     try {
10136       result = (float)((Dali::Radian const *)arg1)->operator float();
10137     } catch (std::out_of_range& e) {
10138       {
10139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10140       };
10141     } catch (std::exception& e) {
10142       {
10143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10144       };
10145     } catch (Dali::DaliException e) {
10146       {
10147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10148       };
10149     } catch (...) {
10150       {
10151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10152       };
10153     }
10154   }
10155
10156   jresult = result;
10157   return jresult;
10158 }
10159
10160
10161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10162   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10163   float arg2 ;
10164
10165   arg1 = (Dali::Radian *)jarg1;
10166   arg2 = (float)jarg2;
10167   if (arg1) (arg1)->radian = arg2;
10168 }
10169
10170
10171 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10172   float jresult ;
10173   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10174   float result;
10175
10176   arg1 = (Dali::Radian *)jarg1;
10177   result = (float) ((arg1)->radian);
10178   jresult = result;
10179   return jresult;
10180 }
10181
10182
10183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10184   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10185
10186   arg1 = (Dali::Radian *)jarg1;
10187   {
10188     try {
10189       delete arg1;
10190     } catch (std::out_of_range& e) {
10191       {
10192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10193       };
10194     } catch (std::exception& e) {
10195       {
10196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10197       };
10198     } catch (Dali::DaliException e) {
10199       {
10200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10201       };
10202     } catch (...) {
10203       {
10204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10205       };
10206     }
10207   }
10208
10209 }
10210
10211
10212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10213   unsigned int jresult ;
10214   Dali::Radian arg1 ;
10215   Dali::Radian arg2 ;
10216   Dali::Radian *argp1 ;
10217   Dali::Radian *argp2 ;
10218   bool result;
10219
10220   argp1 = (Dali::Radian *)jarg1;
10221   if (!argp1) {
10222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10223     return 0;
10224   }
10225   arg1 = *argp1;
10226   argp2 = (Dali::Radian *)jarg2;
10227   if (!argp2) {
10228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10229     return 0;
10230   }
10231   arg2 = *argp2;
10232   {
10233     try {
10234       result = (bool)Dali::operator ==(arg1,arg2);
10235     } catch (std::out_of_range& e) {
10236       {
10237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10238       };
10239     } catch (std::exception& e) {
10240       {
10241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10242       };
10243     } catch (Dali::DaliException e) {
10244       {
10245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10246       };
10247     } catch (...) {
10248       {
10249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10250       };
10251     }
10252   }
10253
10254   jresult = result;
10255   return jresult;
10256 }
10257
10258
10259 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10260   unsigned int jresult ;
10261   Dali::Radian arg1 ;
10262   Dali::Radian arg2 ;
10263   Dali::Radian *argp1 ;
10264   Dali::Radian *argp2 ;
10265   bool result;
10266
10267   argp1 = (Dali::Radian *)jarg1;
10268   if (!argp1) {
10269     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10270     return 0;
10271   }
10272   arg1 = *argp1;
10273   argp2 = (Dali::Radian *)jarg2;
10274   if (!argp2) {
10275     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10276     return 0;
10277   }
10278   arg2 = *argp2;
10279   {
10280     try {
10281       result = (bool)Dali::operator !=(arg1,arg2);
10282     } catch (std::out_of_range& e) {
10283       {
10284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10285       };
10286     } catch (std::exception& e) {
10287       {
10288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10289       };
10290     } catch (Dali::DaliException e) {
10291       {
10292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10293       };
10294     } catch (...) {
10295       {
10296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10297       };
10298     }
10299   }
10300
10301   jresult = result;
10302   return jresult;
10303 }
10304
10305
10306 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10307   unsigned int jresult ;
10308   Dali::Radian arg1 ;
10309   Dali::Degree arg2 ;
10310   Dali::Radian *argp1 ;
10311   Dali::Degree *argp2 ;
10312   bool result;
10313
10314   argp1 = (Dali::Radian *)jarg1;
10315   if (!argp1) {
10316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10317     return 0;
10318   }
10319   arg1 = *argp1;
10320   argp2 = (Dali::Degree *)jarg2;
10321   if (!argp2) {
10322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10323     return 0;
10324   }
10325   arg2 = *argp2;
10326   {
10327     try {
10328       result = (bool)Dali::operator ==(arg1,arg2);
10329     } catch (std::out_of_range& e) {
10330       {
10331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10332       };
10333     } catch (std::exception& e) {
10334       {
10335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10336       };
10337     } catch (Dali::DaliException e) {
10338       {
10339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10340       };
10341     } catch (...) {
10342       {
10343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10344       };
10345     }
10346   }
10347
10348   jresult = result;
10349   return jresult;
10350 }
10351
10352
10353 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10354   unsigned int jresult ;
10355   Dali::Radian arg1 ;
10356   Dali::Degree arg2 ;
10357   Dali::Radian *argp1 ;
10358   Dali::Degree *argp2 ;
10359   bool result;
10360
10361   argp1 = (Dali::Radian *)jarg1;
10362   if (!argp1) {
10363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10364     return 0;
10365   }
10366   arg1 = *argp1;
10367   argp2 = (Dali::Degree *)jarg2;
10368   if (!argp2) {
10369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10370     return 0;
10371   }
10372   arg2 = *argp2;
10373   {
10374     try {
10375       result = (bool)Dali::operator !=(arg1,arg2);
10376     } catch (std::out_of_range& e) {
10377       {
10378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10379       };
10380     } catch (std::exception& e) {
10381       {
10382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10383       };
10384     } catch (Dali::DaliException e) {
10385       {
10386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10387       };
10388     } catch (...) {
10389       {
10390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10391       };
10392     }
10393   }
10394
10395   jresult = result;
10396   return jresult;
10397 }
10398
10399
10400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10401   unsigned int jresult ;
10402   Dali::Degree arg1 ;
10403   Dali::Radian arg2 ;
10404   Dali::Degree *argp1 ;
10405   Dali::Radian *argp2 ;
10406   bool result;
10407
10408   argp1 = (Dali::Degree *)jarg1;
10409   if (!argp1) {
10410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10411     return 0;
10412   }
10413   arg1 = *argp1;
10414   argp2 = (Dali::Radian *)jarg2;
10415   if (!argp2) {
10416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10417     return 0;
10418   }
10419   arg2 = *argp2;
10420   {
10421     try {
10422       result = (bool)Dali::operator ==(arg1,arg2);
10423     } catch (std::out_of_range& e) {
10424       {
10425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10426       };
10427     } catch (std::exception& e) {
10428       {
10429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10430       };
10431     } catch (Dali::DaliException e) {
10432       {
10433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10434       };
10435     } catch (...) {
10436       {
10437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10438       };
10439     }
10440   }
10441
10442   jresult = result;
10443   return jresult;
10444 }
10445
10446
10447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10448   unsigned int jresult ;
10449   Dali::Degree arg1 ;
10450   Dali::Radian arg2 ;
10451   Dali::Degree *argp1 ;
10452   Dali::Radian *argp2 ;
10453   bool result;
10454
10455   argp1 = (Dali::Degree *)jarg1;
10456   if (!argp1) {
10457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10458     return 0;
10459   }
10460   arg1 = *argp1;
10461   argp2 = (Dali::Radian *)jarg2;
10462   if (!argp2) {
10463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10464     return 0;
10465   }
10466   arg2 = *argp2;
10467   {
10468     try {
10469       result = (bool)Dali::operator !=(arg1,arg2);
10470     } catch (std::out_of_range& e) {
10471       {
10472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10473       };
10474     } catch (std::exception& e) {
10475       {
10476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10477       };
10478     } catch (Dali::DaliException e) {
10479       {
10480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10481       };
10482     } catch (...) {
10483       {
10484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10485       };
10486     }
10487   }
10488
10489   jresult = result;
10490   return jresult;
10491 }
10492
10493
10494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10495   unsigned int jresult ;
10496   Dali::Radian arg1 ;
10497   Dali::Radian arg2 ;
10498   Dali::Radian *argp1 ;
10499   Dali::Radian *argp2 ;
10500   bool result;
10501
10502   argp1 = (Dali::Radian *)jarg1;
10503   if (!argp1) {
10504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10505     return 0;
10506   }
10507   arg1 = *argp1;
10508   argp2 = (Dali::Radian *)jarg2;
10509   if (!argp2) {
10510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10511     return 0;
10512   }
10513   arg2 = *argp2;
10514   {
10515     try {
10516       result = (bool)Dali::operator >(arg1,arg2);
10517     } catch (std::out_of_range& e) {
10518       {
10519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10520       };
10521     } catch (std::exception& e) {
10522       {
10523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10524       };
10525     } catch (Dali::DaliException e) {
10526       {
10527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10528       };
10529     } catch (...) {
10530       {
10531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10532       };
10533     }
10534   }
10535
10536   jresult = result;
10537   return jresult;
10538 }
10539
10540
10541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10542   unsigned int jresult ;
10543   Dali::Radian arg1 ;
10544   Dali::Degree arg2 ;
10545   Dali::Radian *argp1 ;
10546   Dali::Degree *argp2 ;
10547   bool result;
10548
10549   argp1 = (Dali::Radian *)jarg1;
10550   if (!argp1) {
10551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10552     return 0;
10553   }
10554   arg1 = *argp1;
10555   argp2 = (Dali::Degree *)jarg2;
10556   if (!argp2) {
10557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10558     return 0;
10559   }
10560   arg2 = *argp2;
10561   {
10562     try {
10563       result = (bool)Dali::operator >(arg1,arg2);
10564     } catch (std::out_of_range& e) {
10565       {
10566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10567       };
10568     } catch (std::exception& e) {
10569       {
10570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10571       };
10572     } catch (Dali::DaliException e) {
10573       {
10574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10575       };
10576     } catch (...) {
10577       {
10578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10579       };
10580     }
10581   }
10582
10583   jresult = result;
10584   return jresult;
10585 }
10586
10587
10588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10589   unsigned int jresult ;
10590   Dali::Degree arg1 ;
10591   Dali::Radian arg2 ;
10592   Dali::Degree *argp1 ;
10593   Dali::Radian *argp2 ;
10594   bool result;
10595
10596   argp1 = (Dali::Degree *)jarg1;
10597   if (!argp1) {
10598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10599     return 0;
10600   }
10601   arg1 = *argp1;
10602   argp2 = (Dali::Radian *)jarg2;
10603   if (!argp2) {
10604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10605     return 0;
10606   }
10607   arg2 = *argp2;
10608   {
10609     try {
10610       result = (bool)Dali::operator >(arg1,arg2);
10611     } catch (std::out_of_range& e) {
10612       {
10613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10614       };
10615     } catch (std::exception& e) {
10616       {
10617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10618       };
10619     } catch (Dali::DaliException e) {
10620       {
10621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10622       };
10623     } catch (...) {
10624       {
10625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10626       };
10627     }
10628   }
10629
10630   jresult = result;
10631   return jresult;
10632 }
10633
10634
10635 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10636   unsigned int jresult ;
10637   Dali::Radian arg1 ;
10638   Dali::Radian arg2 ;
10639   Dali::Radian *argp1 ;
10640   Dali::Radian *argp2 ;
10641   bool result;
10642
10643   argp1 = (Dali::Radian *)jarg1;
10644   if (!argp1) {
10645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10646     return 0;
10647   }
10648   arg1 = *argp1;
10649   argp2 = (Dali::Radian *)jarg2;
10650   if (!argp2) {
10651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10652     return 0;
10653   }
10654   arg2 = *argp2;
10655   {
10656     try {
10657       result = (bool)Dali::operator <(arg1,arg2);
10658     } catch (std::out_of_range& e) {
10659       {
10660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10661       };
10662     } catch (std::exception& e) {
10663       {
10664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10665       };
10666     } catch (Dali::DaliException e) {
10667       {
10668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10669       };
10670     } catch (...) {
10671       {
10672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10673       };
10674     }
10675   }
10676
10677   jresult = result;
10678   return jresult;
10679 }
10680
10681
10682 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10683   unsigned int jresult ;
10684   Dali::Radian arg1 ;
10685   Dali::Degree arg2 ;
10686   Dali::Radian *argp1 ;
10687   Dali::Degree *argp2 ;
10688   bool result;
10689
10690   argp1 = (Dali::Radian *)jarg1;
10691   if (!argp1) {
10692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10693     return 0;
10694   }
10695   arg1 = *argp1;
10696   argp2 = (Dali::Degree *)jarg2;
10697   if (!argp2) {
10698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10699     return 0;
10700   }
10701   arg2 = *argp2;
10702   {
10703     try {
10704       result = (bool)Dali::operator <(arg1,arg2);
10705     } catch (std::out_of_range& e) {
10706       {
10707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10708       };
10709     } catch (std::exception& e) {
10710       {
10711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10712       };
10713     } catch (Dali::DaliException e) {
10714       {
10715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10716       };
10717     } catch (...) {
10718       {
10719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10720       };
10721     }
10722   }
10723
10724   jresult = result;
10725   return jresult;
10726 }
10727
10728
10729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10730   unsigned int jresult ;
10731   Dali::Degree arg1 ;
10732   Dali::Radian arg2 ;
10733   Dali::Degree *argp1 ;
10734   Dali::Radian *argp2 ;
10735   bool result;
10736
10737   argp1 = (Dali::Degree *)jarg1;
10738   if (!argp1) {
10739     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10740     return 0;
10741   }
10742   arg1 = *argp1;
10743   argp2 = (Dali::Radian *)jarg2;
10744   if (!argp2) {
10745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10746     return 0;
10747   }
10748   arg2 = *argp2;
10749   {
10750     try {
10751       result = (bool)Dali::operator <(arg1,arg2);
10752     } catch (std::out_of_range& e) {
10753       {
10754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10755       };
10756     } catch (std::exception& e) {
10757       {
10758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10759       };
10760     } catch (Dali::DaliException e) {
10761       {
10762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10763       };
10764     } catch (...) {
10765       {
10766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10767       };
10768     }
10769   }
10770
10771   jresult = result;
10772   return jresult;
10773 }
10774
10775
10776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10777   void * jresult ;
10778   Dali::Radian arg1 ;
10779   float arg2 ;
10780   Dali::Radian *argp1 ;
10781   Dali::Radian result;
10782
10783   argp1 = (Dali::Radian *)jarg1;
10784   if (!argp1) {
10785     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10786     return 0;
10787   }
10788   arg1 = *argp1;
10789   arg2 = (float)jarg2;
10790   {
10791     try {
10792       result = Dali::operator *(arg1,arg2);
10793     } catch (std::out_of_range& e) {
10794       {
10795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10796       };
10797     } catch (std::exception& e) {
10798       {
10799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10800       };
10801     } catch (Dali::DaliException e) {
10802       {
10803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10804       };
10805     } catch (...) {
10806       {
10807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10808       };
10809     }
10810   }
10811
10812   jresult = new Dali::Radian((const Dali::Radian &)result);
10813   return jresult;
10814 }
10815
10816
10817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10818   void * jresult ;
10819   Dali::Radian arg1 ;
10820   Dali::Radian *argp1 ;
10821   Dali::Radian result;
10822
10823   argp1 = (Dali::Radian *)jarg1;
10824   if (!argp1) {
10825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10826     return 0;
10827   }
10828   arg1 = *argp1;
10829   {
10830     try {
10831       result = Dali::operator -(arg1);
10832     } catch (std::out_of_range& e) {
10833       {
10834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10835       };
10836     } catch (std::exception& e) {
10837       {
10838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10839       };
10840     } catch (Dali::DaliException e) {
10841       {
10842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10843       };
10844     } catch (...) {
10845       {
10846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10847       };
10848     }
10849   }
10850
10851   jresult = new Dali::Radian((const Dali::Radian &)result);
10852   return jresult;
10853 }
10854
10855
10856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10857   void * jresult ;
10858   Dali::Radian arg1 ;
10859   float arg2 ;
10860   float arg3 ;
10861   Dali::Radian *argp1 ;
10862   Dali::Radian result;
10863
10864   argp1 = (Dali::Radian *)jarg1;
10865   if (!argp1) {
10866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10867     return 0;
10868   }
10869   arg1 = *argp1;
10870   arg2 = (float)jarg2;
10871   arg3 = (float)jarg3;
10872   {
10873     try {
10874       result = Dali::Clamp(arg1,arg2,arg3);
10875     } catch (std::out_of_range& e) {
10876       {
10877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10878       };
10879     } catch (std::exception& e) {
10880       {
10881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10882       };
10883     } catch (Dali::DaliException e) {
10884       {
10885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10886       };
10887     } catch (...) {
10888       {
10889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10890       };
10891     }
10892   }
10893
10894   jresult = new Dali::Radian((const Dali::Radian &)result);
10895   return jresult;
10896 }
10897
10898
10899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10900   void * jresult ;
10901   Dali::Quaternion *result = 0 ;
10902
10903   {
10904     try {
10905       result = (Dali::Quaternion *)new Dali::Quaternion();
10906     } catch (std::out_of_range& e) {
10907       {
10908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10909       };
10910     } catch (std::exception& e) {
10911       {
10912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10913       };
10914     } catch (Dali::DaliException e) {
10915       {
10916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10917       };
10918     } catch (...) {
10919       {
10920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10921       };
10922     }
10923   }
10924
10925   jresult = (void *)result;
10926   return jresult;
10927 }
10928
10929
10930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10931   void * jresult ;
10932   Dali::Radian arg1 ;
10933   Dali::Vector3 *arg2 = 0 ;
10934   Dali::Radian *argp1 ;
10935   Dali::Quaternion *result = 0 ;
10936
10937   argp1 = (Dali::Radian *)jarg1;
10938   if (!argp1) {
10939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10940     return 0;
10941   }
10942   arg1 = *argp1;
10943   arg2 = (Dali::Vector3 *)jarg2;
10944   if (!arg2) {
10945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10946     return 0;
10947   }
10948   {
10949     try {
10950       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
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 (Dali::DaliException e) {
10960       {
10961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10962       };
10963     } catch (...) {
10964       {
10965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10966       };
10967     }
10968   }
10969
10970   jresult = (void *)result;
10971   return jresult;
10972 }
10973
10974
10975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10976   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10977
10978   arg1 = (Dali::Quaternion *)jarg1;
10979   {
10980     try {
10981       delete arg1;
10982     } catch (std::out_of_range& e) {
10983       {
10984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10985       };
10986     } catch (std::exception& e) {
10987       {
10988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10989       };
10990     } catch (Dali::DaliException e) {
10991       {
10992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10993       };
10994     } catch (...) {
10995       {
10996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10997       };
10998     }
10999   }
11000
11001 }
11002
11003
11004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
11005   void * jresult ;
11006   Dali::Quaternion *result = 0 ;
11007
11008   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
11009   jresult = (void *)result;
11010   return jresult;
11011 }
11012
11013
11014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
11015   unsigned int jresult ;
11016   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11017   bool result;
11018
11019   arg1 = (Dali::Quaternion *)jarg1;
11020   {
11021     try {
11022       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
11023     } catch (std::out_of_range& e) {
11024       {
11025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11026       };
11027     } catch (std::exception& e) {
11028       {
11029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11030       };
11031     } catch (Dali::DaliException e) {
11032       {
11033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11034       };
11035     } catch (...) {
11036       {
11037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11038       };
11039     }
11040   }
11041
11042   jresult = result;
11043   return jresult;
11044 }
11045
11046
11047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
11048   unsigned int jresult ;
11049   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11050   Dali::Vector3 *arg2 = 0 ;
11051   Dali::Radian *arg3 = 0 ;
11052   bool result;
11053
11054   arg1 = (Dali::Quaternion *)jarg1;
11055   arg2 = (Dali::Vector3 *)jarg2;
11056   if (!arg2) {
11057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11058     return 0;
11059   }
11060   arg3 = (Dali::Radian *)jarg3;
11061   if (!arg3) {
11062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11063     return 0;
11064   }
11065   {
11066     try {
11067       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11068     } catch (std::out_of_range& e) {
11069       {
11070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11071       };
11072     } catch (std::exception& e) {
11073       {
11074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11075       };
11076     } catch (Dali::DaliException e) {
11077       {
11078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11079       };
11080     } catch (...) {
11081       {
11082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11083       };
11084     }
11085   }
11086
11087   jresult = result;
11088   return jresult;
11089 }
11090
11091
11092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11093   void * jresult ;
11094   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11095   Dali::Quaternion *arg2 = 0 ;
11096   Dali::Quaternion result;
11097
11098   arg1 = (Dali::Quaternion *)jarg1;
11099   arg2 = (Dali::Quaternion *)jarg2;
11100   if (!arg2) {
11101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11102     return 0;
11103   }
11104   {
11105     try {
11106       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
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 (Dali::DaliException e) {
11116       {
11117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11118       };
11119     } catch (...) {
11120       {
11121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11122       };
11123     }
11124   }
11125
11126   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11127   return jresult;
11128 }
11129
11130
11131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11132   void * jresult ;
11133   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11134   Dali::Quaternion *arg2 = 0 ;
11135   Dali::Quaternion result;
11136
11137   arg1 = (Dali::Quaternion *)jarg1;
11138   arg2 = (Dali::Quaternion *)jarg2;
11139   if (!arg2) {
11140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11141     return 0;
11142   }
11143   {
11144     try {
11145       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11146     } catch (std::out_of_range& e) {
11147       {
11148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11149       };
11150     } catch (std::exception& e) {
11151       {
11152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11153       };
11154     } catch (Dali::DaliException e) {
11155       {
11156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11157       };
11158     } catch (...) {
11159       {
11160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11161       };
11162     }
11163   }
11164
11165   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11166   return jresult;
11167 }
11168
11169
11170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11171   void * jresult ;
11172   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11173   Dali::Quaternion *arg2 = 0 ;
11174   Dali::Quaternion result;
11175
11176   arg1 = (Dali::Quaternion *)jarg1;
11177   arg2 = (Dali::Quaternion *)jarg2;
11178   if (!arg2) {
11179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11180     return 0;
11181   }
11182   {
11183     try {
11184       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11185     } catch (std::out_of_range& e) {
11186       {
11187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11188       };
11189     } catch (std::exception& e) {
11190       {
11191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11192       };
11193     } catch (Dali::DaliException e) {
11194       {
11195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11196       };
11197     } catch (...) {
11198       {
11199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11200       };
11201     }
11202   }
11203
11204   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11205   return jresult;
11206 }
11207
11208
11209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11210   void * jresult ;
11211   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11212   Dali::Vector3 *arg2 = 0 ;
11213   Dali::Vector3 result;
11214
11215   arg1 = (Dali::Quaternion *)jarg1;
11216   arg2 = (Dali::Vector3 *)jarg2;
11217   if (!arg2) {
11218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11219     return 0;
11220   }
11221   {
11222     try {
11223       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11224     } catch (std::out_of_range& e) {
11225       {
11226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11227       };
11228     } catch (std::exception& e) {
11229       {
11230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11231       };
11232     } catch (Dali::DaliException e) {
11233       {
11234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11235       };
11236     } catch (...) {
11237       {
11238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11239       };
11240     }
11241   }
11242
11243   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11244   return jresult;
11245 }
11246
11247
11248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11249   void * jresult ;
11250   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11251   Dali::Quaternion *arg2 = 0 ;
11252   Dali::Quaternion result;
11253
11254   arg1 = (Dali::Quaternion *)jarg1;
11255   arg2 = (Dali::Quaternion *)jarg2;
11256   if (!arg2) {
11257     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11258     return 0;
11259   }
11260   {
11261     try {
11262       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11263     } catch (std::out_of_range& e) {
11264       {
11265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11266       };
11267     } catch (std::exception& e) {
11268       {
11269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11270       };
11271     } catch (Dali::DaliException e) {
11272       {
11273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11274       };
11275     } catch (...) {
11276       {
11277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11278       };
11279     }
11280   }
11281
11282   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11283   return jresult;
11284 }
11285
11286
11287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11288   void * jresult ;
11289   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11290   float arg2 ;
11291   Dali::Quaternion result;
11292
11293   arg1 = (Dali::Quaternion *)jarg1;
11294   arg2 = (float)jarg2;
11295   {
11296     try {
11297       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11298     } catch (std::out_of_range& e) {
11299       {
11300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11301       };
11302     } catch (std::exception& e) {
11303       {
11304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11305       };
11306     } catch (Dali::DaliException e) {
11307       {
11308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11309       };
11310     } catch (...) {
11311       {
11312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11313       };
11314     }
11315   }
11316
11317   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11318   return jresult;
11319 }
11320
11321
11322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11323   void * jresult ;
11324   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11325   float arg2 ;
11326   Dali::Quaternion result;
11327
11328   arg1 = (Dali::Quaternion *)jarg1;
11329   arg2 = (float)jarg2;
11330   {
11331     try {
11332       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
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 (Dali::DaliException e) {
11342       {
11343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11344       };
11345     } catch (...) {
11346       {
11347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11348       };
11349     }
11350   }
11351
11352   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11353   return jresult;
11354 }
11355
11356
11357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11358   void * jresult ;
11359   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11360   Dali::Quaternion result;
11361
11362   arg1 = (Dali::Quaternion *)jarg1;
11363   {
11364     try {
11365       result = ((Dali::Quaternion const *)arg1)->operator -();
11366     } catch (std::out_of_range& e) {
11367       {
11368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11369       };
11370     } catch (std::exception& e) {
11371       {
11372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11373       };
11374     } catch (Dali::DaliException e) {
11375       {
11376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11377       };
11378     } catch (...) {
11379       {
11380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11381       };
11382     }
11383   }
11384
11385   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11386   return jresult;
11387 }
11388
11389
11390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11391   void * jresult ;
11392   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11393   Dali::Quaternion *arg2 = 0 ;
11394   Dali::Quaternion *result = 0 ;
11395
11396   arg1 = (Dali::Quaternion *)jarg1;
11397   arg2 = (Dali::Quaternion *)jarg2;
11398   if (!arg2) {
11399     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11400     return 0;
11401   }
11402   {
11403     try {
11404       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11405     } catch (std::out_of_range& e) {
11406       {
11407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11408       };
11409     } catch (std::exception& e) {
11410       {
11411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11412       };
11413     } catch (Dali::DaliException e) {
11414       {
11415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11416       };
11417     } catch (...) {
11418       {
11419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11420       };
11421     }
11422   }
11423
11424   jresult = (void *)result;
11425   return jresult;
11426 }
11427
11428
11429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11430   void * jresult ;
11431   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11432   Dali::Quaternion *arg2 = 0 ;
11433   Dali::Quaternion *result = 0 ;
11434
11435   arg1 = (Dali::Quaternion *)jarg1;
11436   arg2 = (Dali::Quaternion *)jarg2;
11437   if (!arg2) {
11438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11439     return 0;
11440   }
11441   {
11442     try {
11443       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11444     } catch (std::out_of_range& e) {
11445       {
11446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11447       };
11448     } catch (std::exception& e) {
11449       {
11450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11451       };
11452     } catch (Dali::DaliException e) {
11453       {
11454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11455       };
11456     } catch (...) {
11457       {
11458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11459       };
11460     }
11461   }
11462
11463   jresult = (void *)result;
11464   return jresult;
11465 }
11466
11467
11468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11469   void * jresult ;
11470   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11471   Dali::Quaternion *arg2 = 0 ;
11472   Dali::Quaternion *result = 0 ;
11473
11474   arg1 = (Dali::Quaternion *)jarg1;
11475   arg2 = (Dali::Quaternion *)jarg2;
11476   if (!arg2) {
11477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11478     return 0;
11479   }
11480   {
11481     try {
11482       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11483     } catch (std::out_of_range& e) {
11484       {
11485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11486       };
11487     } catch (std::exception& e) {
11488       {
11489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11490       };
11491     } catch (Dali::DaliException e) {
11492       {
11493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11494       };
11495     } catch (...) {
11496       {
11497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11498       };
11499     }
11500   }
11501
11502   jresult = (void *)result;
11503   return jresult;
11504 }
11505
11506
11507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11508   void * jresult ;
11509   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11510   float arg2 ;
11511   Dali::Quaternion *result = 0 ;
11512
11513   arg1 = (Dali::Quaternion *)jarg1;
11514   arg2 = (float)jarg2;
11515   {
11516     try {
11517       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11518     } catch (std::out_of_range& e) {
11519       {
11520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11521       };
11522     } catch (std::exception& e) {
11523       {
11524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11525       };
11526     } catch (Dali::DaliException e) {
11527       {
11528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11529       };
11530     } catch (...) {
11531       {
11532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11533       };
11534     }
11535   }
11536
11537   jresult = (void *)result;
11538   return jresult;
11539 }
11540
11541
11542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11543   void * jresult ;
11544   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11545   float arg2 ;
11546   Dali::Quaternion *result = 0 ;
11547
11548   arg1 = (Dali::Quaternion *)jarg1;
11549   arg2 = (float)jarg2;
11550   {
11551     try {
11552       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11553     } catch (std::out_of_range& e) {
11554       {
11555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11556       };
11557     } catch (std::exception& e) {
11558       {
11559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11560       };
11561     } catch (Dali::DaliException e) {
11562       {
11563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11564       };
11565     } catch (...) {
11566       {
11567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11568       };
11569     }
11570   }
11571
11572   jresult = (void *)result;
11573   return jresult;
11574 }
11575
11576
11577 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11578   unsigned int jresult ;
11579   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11580   Dali::Quaternion *arg2 = 0 ;
11581   bool result;
11582
11583   arg1 = (Dali::Quaternion *)jarg1;
11584   arg2 = (Dali::Quaternion *)jarg2;
11585   if (!arg2) {
11586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11587     return 0;
11588   }
11589   {
11590     try {
11591       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11592     } catch (std::out_of_range& e) {
11593       {
11594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11595       };
11596     } catch (std::exception& e) {
11597       {
11598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11599       };
11600     } catch (Dali::DaliException e) {
11601       {
11602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11603       };
11604     } catch (...) {
11605       {
11606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11607       };
11608     }
11609   }
11610
11611   jresult = result;
11612   return jresult;
11613 }
11614
11615
11616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11617   unsigned int jresult ;
11618   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11619   Dali::Quaternion *arg2 = 0 ;
11620   bool result;
11621
11622   arg1 = (Dali::Quaternion *)jarg1;
11623   arg2 = (Dali::Quaternion *)jarg2;
11624   if (!arg2) {
11625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11626     return 0;
11627   }
11628   {
11629     try {
11630       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11631     } catch (std::out_of_range& e) {
11632       {
11633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11634       };
11635     } catch (std::exception& e) {
11636       {
11637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11638       };
11639     } catch (Dali::DaliException e) {
11640       {
11641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11642       };
11643     } catch (...) {
11644       {
11645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11646       };
11647     }
11648   }
11649
11650   jresult = result;
11651   return jresult;
11652 }
11653
11654
11655 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11656   float jresult ;
11657   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11658   float result;
11659
11660   arg1 = (Dali::Quaternion *)jarg1;
11661   {
11662     try {
11663       result = (float)((Dali::Quaternion const *)arg1)->Length();
11664     } catch (std::out_of_range& e) {
11665       {
11666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11667       };
11668     } catch (std::exception& e) {
11669       {
11670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11671       };
11672     } catch (Dali::DaliException e) {
11673       {
11674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11675       };
11676     } catch (...) {
11677       {
11678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11679       };
11680     }
11681   }
11682
11683   jresult = result;
11684   return jresult;
11685 }
11686
11687
11688 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11689   float jresult ;
11690   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11691   float result;
11692
11693   arg1 = (Dali::Quaternion *)jarg1;
11694   {
11695     try {
11696       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11697     } catch (std::out_of_range& e) {
11698       {
11699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11700       };
11701     } catch (std::exception& e) {
11702       {
11703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11704       };
11705     } catch (Dali::DaliException e) {
11706       {
11707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11708       };
11709     } catch (...) {
11710       {
11711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11712       };
11713     }
11714   }
11715
11716   jresult = result;
11717   return jresult;
11718 }
11719
11720
11721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11722   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11723
11724   arg1 = (Dali::Quaternion *)jarg1;
11725   {
11726     try {
11727       (arg1)->Normalize();
11728     } catch (std::out_of_range& e) {
11729       {
11730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11731       };
11732     } catch (std::exception& e) {
11733       {
11734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11735       };
11736     } catch (Dali::DaliException e) {
11737       {
11738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11739       };
11740     } catch (...) {
11741       {
11742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11743       };
11744     }
11745   }
11746
11747 }
11748
11749
11750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11751   void * jresult ;
11752   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11753   Dali::Quaternion result;
11754
11755   arg1 = (Dali::Quaternion *)jarg1;
11756   {
11757     try {
11758       result = ((Dali::Quaternion const *)arg1)->Normalized();
11759     } catch (std::out_of_range& e) {
11760       {
11761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11762       };
11763     } catch (std::exception& e) {
11764       {
11765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11766       };
11767     } catch (Dali::DaliException e) {
11768       {
11769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11770       };
11771     } catch (...) {
11772       {
11773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11774       };
11775     }
11776   }
11777
11778   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11779   return jresult;
11780 }
11781
11782
11783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11784   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11785
11786   arg1 = (Dali::Quaternion *)jarg1;
11787   {
11788     try {
11789       (arg1)->Conjugate();
11790     } catch (std::out_of_range& e) {
11791       {
11792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11793       };
11794     } catch (std::exception& e) {
11795       {
11796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11797       };
11798     } catch (Dali::DaliException e) {
11799       {
11800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11801       };
11802     } catch (...) {
11803       {
11804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11805       };
11806     }
11807   }
11808
11809 }
11810
11811
11812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11813   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11814
11815   arg1 = (Dali::Quaternion *)jarg1;
11816   {
11817     try {
11818       (arg1)->Invert();
11819     } catch (std::out_of_range& e) {
11820       {
11821         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11822       };
11823     } catch (std::exception& e) {
11824       {
11825         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11826       };
11827     } catch (Dali::DaliException e) {
11828       {
11829         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11830       };
11831     } catch (...) {
11832       {
11833         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11834       };
11835     }
11836   }
11837
11838 }
11839
11840
11841 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11842   void * jresult ;
11843   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11844   Dali::Quaternion result;
11845
11846   arg1 = (Dali::Quaternion *)jarg1;
11847   {
11848     try {
11849       result = ((Dali::Quaternion const *)arg1)->Log();
11850     } catch (std::out_of_range& e) {
11851       {
11852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11853       };
11854     } catch (std::exception& e) {
11855       {
11856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11857       };
11858     } catch (Dali::DaliException e) {
11859       {
11860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11861       };
11862     } catch (...) {
11863       {
11864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11865       };
11866     }
11867   }
11868
11869   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11870   return jresult;
11871 }
11872
11873
11874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11875   void * jresult ;
11876   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11877   Dali::Quaternion result;
11878
11879   arg1 = (Dali::Quaternion *)jarg1;
11880   {
11881     try {
11882       result = ((Dali::Quaternion const *)arg1)->Exp();
11883     } catch (std::out_of_range& e) {
11884       {
11885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11886       };
11887     } catch (std::exception& e) {
11888       {
11889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11890       };
11891     } catch (Dali::DaliException e) {
11892       {
11893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11894       };
11895     } catch (...) {
11896       {
11897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11898       };
11899     }
11900   }
11901
11902   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11903   return jresult;
11904 }
11905
11906
11907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11908   float jresult ;
11909   Dali::Quaternion *arg1 = 0 ;
11910   Dali::Quaternion *arg2 = 0 ;
11911   float result;
11912
11913   arg1 = (Dali::Quaternion *)jarg1;
11914   if (!arg1) {
11915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11916     return 0;
11917   }
11918   arg2 = (Dali::Quaternion *)jarg2;
11919   if (!arg2) {
11920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11921     return 0;
11922   }
11923   {
11924     try {
11925       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11926     } catch (std::out_of_range& e) {
11927       {
11928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11929       };
11930     } catch (std::exception& e) {
11931       {
11932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11933       };
11934     } catch (Dali::DaliException e) {
11935       {
11936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11937       };
11938     } catch (...) {
11939       {
11940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11941       };
11942     }
11943   }
11944
11945   jresult = result;
11946   return jresult;
11947 }
11948
11949
11950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11951   void * jresult ;
11952   Dali::Quaternion *arg1 = 0 ;
11953   Dali::Quaternion *arg2 = 0 ;
11954   float arg3 ;
11955   Dali::Quaternion result;
11956
11957   arg1 = (Dali::Quaternion *)jarg1;
11958   if (!arg1) {
11959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11960     return 0;
11961   }
11962   arg2 = (Dali::Quaternion *)jarg2;
11963   if (!arg2) {
11964     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11965     return 0;
11966   }
11967   arg3 = (float)jarg3;
11968   {
11969     try {
11970       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11971     } catch (std::out_of_range& e) {
11972       {
11973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11974       };
11975     } catch (std::exception& e) {
11976       {
11977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11978       };
11979     } catch (Dali::DaliException e) {
11980       {
11981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11982       };
11983     } catch (...) {
11984       {
11985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11986       };
11987     }
11988   }
11989
11990   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11991   return jresult;
11992 }
11993
11994
11995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11996   void * jresult ;
11997   Dali::Quaternion *arg1 = 0 ;
11998   Dali::Quaternion *arg2 = 0 ;
11999   float arg3 ;
12000   Dali::Quaternion result;
12001
12002   arg1 = (Dali::Quaternion *)jarg1;
12003   if (!arg1) {
12004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12005     return 0;
12006   }
12007   arg2 = (Dali::Quaternion *)jarg2;
12008   if (!arg2) {
12009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12010     return 0;
12011   }
12012   arg3 = (float)jarg3;
12013   {
12014     try {
12015       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12016     } catch (std::out_of_range& e) {
12017       {
12018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12019       };
12020     } catch (std::exception& e) {
12021       {
12022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12023       };
12024     } catch (Dali::DaliException e) {
12025       {
12026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12027       };
12028     } catch (...) {
12029       {
12030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12031       };
12032     }
12033   }
12034
12035   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12036   return jresult;
12037 }
12038
12039
12040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
12041   void * jresult ;
12042   Dali::Quaternion *arg1 = 0 ;
12043   Dali::Quaternion *arg2 = 0 ;
12044   float arg3 ;
12045   Dali::Quaternion result;
12046
12047   arg1 = (Dali::Quaternion *)jarg1;
12048   if (!arg1) {
12049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12050     return 0;
12051   }
12052   arg2 = (Dali::Quaternion *)jarg2;
12053   if (!arg2) {
12054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12055     return 0;
12056   }
12057   arg3 = (float)jarg3;
12058   {
12059     try {
12060       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12061     } catch (std::out_of_range& e) {
12062       {
12063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12064       };
12065     } catch (std::exception& e) {
12066       {
12067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12068       };
12069     } catch (Dali::DaliException e) {
12070       {
12071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12072       };
12073     } catch (...) {
12074       {
12075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12076       };
12077     }
12078   }
12079
12080   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12081   return jresult;
12082 }
12083
12084
12085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12086   void * jresult ;
12087   Dali::Quaternion *arg1 = 0 ;
12088   Dali::Quaternion *arg2 = 0 ;
12089   Dali::Quaternion *arg3 = 0 ;
12090   Dali::Quaternion *arg4 = 0 ;
12091   float arg5 ;
12092   Dali::Quaternion result;
12093
12094   arg1 = (Dali::Quaternion *)jarg1;
12095   if (!arg1) {
12096     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12097     return 0;
12098   }
12099   arg2 = (Dali::Quaternion *)jarg2;
12100   if (!arg2) {
12101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12102     return 0;
12103   }
12104   arg3 = (Dali::Quaternion *)jarg3;
12105   if (!arg3) {
12106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12107     return 0;
12108   }
12109   arg4 = (Dali::Quaternion *)jarg4;
12110   if (!arg4) {
12111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12112     return 0;
12113   }
12114   arg5 = (float)jarg5;
12115   {
12116     try {
12117       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12118     } catch (std::out_of_range& e) {
12119       {
12120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12121       };
12122     } catch (std::exception& e) {
12123       {
12124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12125       };
12126     } catch (Dali::DaliException e) {
12127       {
12128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12129       };
12130     } catch (...) {
12131       {
12132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12133       };
12134     }
12135   }
12136
12137   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12138   return jresult;
12139 }
12140
12141
12142 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12143   float jresult ;
12144   Dali::Quaternion *arg1 = 0 ;
12145   Dali::Quaternion *arg2 = 0 ;
12146   float result;
12147
12148   arg1 = (Dali::Quaternion *)jarg1;
12149   if (!arg1) {
12150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12151     return 0;
12152   }
12153   arg2 = (Dali::Quaternion *)jarg2;
12154   if (!arg2) {
12155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12156     return 0;
12157   }
12158   {
12159     try {
12160       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12161     } catch (std::out_of_range& e) {
12162       {
12163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12164       };
12165     } catch (std::exception& e) {
12166       {
12167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12168       };
12169     } catch (Dali::DaliException e) {
12170       {
12171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12172       };
12173     } catch (...) {
12174       {
12175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12176       };
12177     }
12178   }
12179
12180   jresult = result;
12181   return jresult;
12182 }
12183
12184
12185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12186   void * jresult ;
12187   Dali::Matrix *result = 0 ;
12188
12189   {
12190     try {
12191       result = (Dali::Matrix *)new Dali::Matrix();
12192     } catch (std::out_of_range& e) {
12193       {
12194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12195       };
12196     } catch (std::exception& e) {
12197       {
12198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12199       };
12200     } catch (Dali::DaliException e) {
12201       {
12202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12203       };
12204     } catch (...) {
12205       {
12206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12207       };
12208     }
12209   }
12210
12211   jresult = (void *)result;
12212   return jresult;
12213 }
12214
12215
12216 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12217   void * jresult ;
12218   bool arg1 ;
12219   Dali::Matrix *result = 0 ;
12220
12221   arg1 = jarg1 ? true : false;
12222   {
12223     try {
12224       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12225     } catch (std::out_of_range& e) {
12226       {
12227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12228       };
12229     } catch (std::exception& e) {
12230       {
12231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12232       };
12233     } catch (Dali::DaliException e) {
12234       {
12235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12236       };
12237     } catch (...) {
12238       {
12239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12240       };
12241     }
12242   }
12243
12244   jresult = (void *)result;
12245   return jresult;
12246 }
12247
12248
12249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12250   void * jresult ;
12251   float *arg1 = (float *) 0 ;
12252   Dali::Matrix *result = 0 ;
12253
12254   arg1 = jarg1;
12255   {
12256     try {
12257       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12258     } catch (std::out_of_range& e) {
12259       {
12260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12261       };
12262     } catch (std::exception& e) {
12263       {
12264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12265       };
12266     } catch (Dali::DaliException e) {
12267       {
12268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12269       };
12270     } catch (...) {
12271       {
12272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12273       };
12274     }
12275   }
12276
12277   jresult = (void *)result;
12278
12279
12280   return jresult;
12281 }
12282
12283
12284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12285   void * jresult ;
12286   Dali::Quaternion *arg1 = 0 ;
12287   Dali::Matrix *result = 0 ;
12288
12289   arg1 = (Dali::Quaternion *)jarg1;
12290   if (!arg1) {
12291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12292     return 0;
12293   }
12294   {
12295     try {
12296       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12297     } catch (std::out_of_range& e) {
12298       {
12299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12300       };
12301     } catch (std::exception& e) {
12302       {
12303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12304       };
12305     } catch (Dali::DaliException e) {
12306       {
12307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12308       };
12309     } catch (...) {
12310       {
12311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12312       };
12313     }
12314   }
12315
12316   jresult = (void *)result;
12317   return jresult;
12318 }
12319
12320
12321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12322   void * jresult ;
12323   Dali::Matrix *arg1 = 0 ;
12324   Dali::Matrix *result = 0 ;
12325
12326   arg1 = (Dali::Matrix *)jarg1;
12327   if (!arg1) {
12328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12329     return 0;
12330   }
12331   {
12332     try {
12333       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12334     } catch (std::out_of_range& e) {
12335       {
12336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12337       };
12338     } catch (std::exception& e) {
12339       {
12340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12341       };
12342     } catch (Dali::DaliException e) {
12343       {
12344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12345       };
12346     } catch (...) {
12347       {
12348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12349       };
12350     }
12351   }
12352
12353   jresult = (void *)result;
12354   return jresult;
12355 }
12356
12357
12358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12359   void * jresult ;
12360   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12361   Dali::Matrix *arg2 = 0 ;
12362   Dali::Matrix *result = 0 ;
12363
12364   arg1 = (Dali::Matrix *)jarg1;
12365   arg2 = (Dali::Matrix *)jarg2;
12366   if (!arg2) {
12367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12368     return 0;
12369   }
12370   {
12371     try {
12372       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12373     } catch (std::out_of_range& e) {
12374       {
12375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12376       };
12377     } catch (std::exception& e) {
12378       {
12379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12380       };
12381     } catch (Dali::DaliException e) {
12382       {
12383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12384       };
12385     } catch (...) {
12386       {
12387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12388       };
12389     }
12390   }
12391
12392   jresult = (void *)result;
12393   return jresult;
12394 }
12395
12396
12397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12398   void * jresult ;
12399   Dali::Matrix *result = 0 ;
12400
12401   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12402   jresult = (void *)result;
12403   return jresult;
12404 }
12405
12406
12407 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12408   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12409
12410   arg1 = (Dali::Matrix *)jarg1;
12411   {
12412     try {
12413       (arg1)->SetIdentity();
12414     } catch (std::out_of_range& e) {
12415       {
12416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12417       };
12418     } catch (std::exception& e) {
12419       {
12420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12421       };
12422     } catch (Dali::DaliException e) {
12423       {
12424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12425       };
12426     } catch (...) {
12427       {
12428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12429       };
12430     }
12431   }
12432
12433 }
12434
12435
12436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12437   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12438   Dali::Vector3 *arg2 = 0 ;
12439
12440   arg1 = (Dali::Matrix *)jarg1;
12441   arg2 = (Dali::Vector3 *)jarg2;
12442   if (!arg2) {
12443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12444     return ;
12445   }
12446   {
12447     try {
12448       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12449     } catch (std::out_of_range& e) {
12450       {
12451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12452       };
12453     } catch (std::exception& e) {
12454       {
12455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12456       };
12457     } catch (Dali::DaliException e) {
12458       {
12459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12460       };
12461     } catch (...) {
12462       {
12463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12464       };
12465     }
12466   }
12467
12468 }
12469
12470
12471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12472   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12473   Dali::Matrix *arg2 = 0 ;
12474
12475   arg1 = (Dali::Matrix *)jarg1;
12476   arg2 = (Dali::Matrix *)jarg2;
12477   if (!arg2) {
12478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12479     return ;
12480   }
12481   {
12482     try {
12483       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12484     } catch (std::out_of_range& e) {
12485       {
12486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12487       };
12488     } catch (std::exception& e) {
12489       {
12490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12491       };
12492     } catch (Dali::DaliException e) {
12493       {
12494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12495       };
12496     } catch (...) {
12497       {
12498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12499       };
12500     }
12501   }
12502
12503 }
12504
12505
12506 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12507   unsigned int jresult ;
12508   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12509   bool result;
12510
12511   arg1 = (Dali::Matrix *)jarg1;
12512   {
12513     try {
12514       result = (bool)(arg1)->Invert();
12515     } catch (std::out_of_range& e) {
12516       {
12517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12518       };
12519     } catch (std::exception& e) {
12520       {
12521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12522       };
12523     } catch (Dali::DaliException e) {
12524       {
12525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12526       };
12527     } catch (...) {
12528       {
12529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12530       };
12531     }
12532   }
12533
12534   jresult = result;
12535   return jresult;
12536 }
12537
12538
12539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12540   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12541
12542   arg1 = (Dali::Matrix *)jarg1;
12543   {
12544     try {
12545       (arg1)->Transpose();
12546     } catch (std::out_of_range& e) {
12547       {
12548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12549       };
12550     } catch (std::exception& e) {
12551       {
12552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12553       };
12554     } catch (Dali::DaliException e) {
12555       {
12556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12557       };
12558     } catch (...) {
12559       {
12560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12561       };
12562     }
12563   }
12564
12565 }
12566
12567
12568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12569   void * jresult ;
12570   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12571   Dali::Vector3 result;
12572
12573   arg1 = (Dali::Matrix *)jarg1;
12574   {
12575     try {
12576       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12577     } catch (std::out_of_range& e) {
12578       {
12579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12580       };
12581     } catch (std::exception& e) {
12582       {
12583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12584       };
12585     } catch (Dali::DaliException e) {
12586       {
12587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12588       };
12589     } catch (...) {
12590       {
12591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12592       };
12593     }
12594   }
12595
12596   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12597   return jresult;
12598 }
12599
12600
12601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12602   void * jresult ;
12603   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12604   Dali::Vector3 result;
12605
12606   arg1 = (Dali::Matrix *)jarg1;
12607   {
12608     try {
12609       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12610     } catch (std::out_of_range& e) {
12611       {
12612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12613       };
12614     } catch (std::exception& e) {
12615       {
12616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12617       };
12618     } catch (Dali::DaliException e) {
12619       {
12620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12621       };
12622     } catch (...) {
12623       {
12624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12625       };
12626     }
12627   }
12628
12629   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12630   return jresult;
12631 }
12632
12633
12634 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12635   void * jresult ;
12636   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12637   Dali::Vector3 result;
12638
12639   arg1 = (Dali::Matrix *)jarg1;
12640   {
12641     try {
12642       result = ((Dali::Matrix const *)arg1)->GetZAxis();
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 (Dali::DaliException e) {
12652       {
12653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12654       };
12655     } catch (...) {
12656       {
12657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12658       };
12659     }
12660   }
12661
12662   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12663   return jresult;
12664 }
12665
12666
12667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12668   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12669   Dali::Vector3 *arg2 = 0 ;
12670
12671   arg1 = (Dali::Matrix *)jarg1;
12672   arg2 = (Dali::Vector3 *)jarg2;
12673   if (!arg2) {
12674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12675     return ;
12676   }
12677   {
12678     try {
12679       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12680     } catch (std::out_of_range& e) {
12681       {
12682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12683       };
12684     } catch (std::exception& e) {
12685       {
12686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12687       };
12688     } catch (Dali::DaliException e) {
12689       {
12690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12691       };
12692     } catch (...) {
12693       {
12694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12695       };
12696     }
12697   }
12698
12699 }
12700
12701
12702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12703   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12704   Dali::Vector3 *arg2 = 0 ;
12705
12706   arg1 = (Dali::Matrix *)jarg1;
12707   arg2 = (Dali::Vector3 *)jarg2;
12708   if (!arg2) {
12709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12710     return ;
12711   }
12712   {
12713     try {
12714       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12715     } catch (std::out_of_range& e) {
12716       {
12717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12718       };
12719     } catch (std::exception& e) {
12720       {
12721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12722       };
12723     } catch (Dali::DaliException e) {
12724       {
12725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12726       };
12727     } catch (...) {
12728       {
12729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12730       };
12731     }
12732   }
12733
12734 }
12735
12736
12737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12738   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12739   Dali::Vector3 *arg2 = 0 ;
12740
12741   arg1 = (Dali::Matrix *)jarg1;
12742   arg2 = (Dali::Vector3 *)jarg2;
12743   if (!arg2) {
12744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12745     return ;
12746   }
12747   {
12748     try {
12749       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12750     } catch (std::out_of_range& e) {
12751       {
12752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12753       };
12754     } catch (std::exception& e) {
12755       {
12756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12757       };
12758     } catch (Dali::DaliException e) {
12759       {
12760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12761       };
12762     } catch (...) {
12763       {
12764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12765       };
12766     }
12767   }
12768
12769 }
12770
12771
12772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12773   void * jresult ;
12774   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12775   Dali::Vector4 *result = 0 ;
12776
12777   arg1 = (Dali::Matrix *)jarg1;
12778   {
12779     try {
12780       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12781     } catch (std::out_of_range& e) {
12782       {
12783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12784       };
12785     } catch (std::exception& e) {
12786       {
12787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12788       };
12789     } catch (Dali::DaliException e) {
12790       {
12791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12792       };
12793     } catch (...) {
12794       {
12795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12796       };
12797     }
12798   }
12799
12800   jresult = (void *)result;
12801   return jresult;
12802 }
12803
12804
12805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12806   void * jresult ;
12807   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12808   Dali::Vector3 *result = 0 ;
12809
12810   arg1 = (Dali::Matrix *)jarg1;
12811   {
12812     try {
12813       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12814     } catch (std::out_of_range& e) {
12815       {
12816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12817       };
12818     } catch (std::exception& e) {
12819       {
12820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12821       };
12822     } catch (Dali::DaliException e) {
12823       {
12824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12825       };
12826     } catch (...) {
12827       {
12828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12829       };
12830     }
12831   }
12832
12833   jresult = (void *)result;
12834   return jresult;
12835 }
12836
12837
12838 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12839   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12840   Dali::Vector4 *arg2 = 0 ;
12841
12842   arg1 = (Dali::Matrix *)jarg1;
12843   arg2 = (Dali::Vector4 *)jarg2;
12844   if (!arg2) {
12845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12846     return ;
12847   }
12848   {
12849     try {
12850       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12851     } catch (std::out_of_range& e) {
12852       {
12853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12854       };
12855     } catch (std::exception& e) {
12856       {
12857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12858       };
12859     } catch (Dali::DaliException e) {
12860       {
12861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12862       };
12863     } catch (...) {
12864       {
12865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12866       };
12867     }
12868   }
12869
12870 }
12871
12872
12873 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12874   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12875   Dali::Vector3 *arg2 = 0 ;
12876
12877   arg1 = (Dali::Matrix *)jarg1;
12878   arg2 = (Dali::Vector3 *)jarg2;
12879   if (!arg2) {
12880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12881     return ;
12882   }
12883   {
12884     try {
12885       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12886     } catch (std::out_of_range& e) {
12887       {
12888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12889       };
12890     } catch (std::exception& e) {
12891       {
12892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12893       };
12894     } catch (Dali::DaliException e) {
12895       {
12896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12897       };
12898     } catch (...) {
12899       {
12900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12901       };
12902     }
12903   }
12904
12905 }
12906
12907
12908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12909   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12910
12911   arg1 = (Dali::Matrix *)jarg1;
12912   {
12913     try {
12914       (arg1)->OrthoNormalize();
12915     } catch (std::out_of_range& e) {
12916       {
12917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12918       };
12919     } catch (std::exception& e) {
12920       {
12921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12922       };
12923     } catch (Dali::DaliException e) {
12924       {
12925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12926       };
12927     } catch (...) {
12928       {
12929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12930       };
12931     }
12932   }
12933
12934 }
12935
12936
12937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12938   void * jresult ;
12939   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12940   float *result = 0 ;
12941
12942   arg1 = (Dali::Matrix *)jarg1;
12943   {
12944     try {
12945       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12946     } catch (std::out_of_range& e) {
12947       {
12948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12949       };
12950     } catch (std::exception& e) {
12951       {
12952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12953       };
12954     } catch (Dali::DaliException e) {
12955       {
12956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12957       };
12958     } catch (...) {
12959       {
12960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12961       };
12962     }
12963   }
12964
12965   jresult = (void *)result;
12966   return jresult;
12967 }
12968
12969
12970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12971   Dali::Matrix *arg1 = 0 ;
12972   Dali::Matrix *arg2 = 0 ;
12973   Dali::Matrix *arg3 = 0 ;
12974
12975   arg1 = (Dali::Matrix *)jarg1;
12976   if (!arg1) {
12977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12978     return ;
12979   }
12980   arg2 = (Dali::Matrix *)jarg2;
12981   if (!arg2) {
12982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12983     return ;
12984   }
12985   arg3 = (Dali::Matrix *)jarg3;
12986   if (!arg3) {
12987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12988     return ;
12989   }
12990   {
12991     try {
12992       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12993     } catch (std::out_of_range& e) {
12994       {
12995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12996       };
12997     } catch (std::exception& e) {
12998       {
12999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13000       };
13001     } catch (Dali::DaliException e) {
13002       {
13003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13004       };
13005     } catch (...) {
13006       {
13007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13008       };
13009     }
13010   }
13011
13012 }
13013
13014
13015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
13016   Dali::Matrix *arg1 = 0 ;
13017   Dali::Matrix *arg2 = 0 ;
13018   Dali::Quaternion *arg3 = 0 ;
13019
13020   arg1 = (Dali::Matrix *)jarg1;
13021   if (!arg1) {
13022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
13023     return ;
13024   }
13025   arg2 = (Dali::Matrix *)jarg2;
13026   if (!arg2) {
13027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13028     return ;
13029   }
13030   arg3 = (Dali::Quaternion *)jarg3;
13031   if (!arg3) {
13032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13033     return ;
13034   }
13035   {
13036     try {
13037       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
13038     } catch (std::out_of_range& e) {
13039       {
13040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13041       };
13042     } catch (std::exception& e) {
13043       {
13044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13045       };
13046     } catch (Dali::DaliException e) {
13047       {
13048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13049       };
13050     } catch (...) {
13051       {
13052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13053       };
13054     }
13055   }
13056
13057 }
13058
13059
13060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13061   void * jresult ;
13062   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13063   Dali::Vector4 *arg2 = 0 ;
13064   Dali::Vector4 result;
13065
13066   arg1 = (Dali::Matrix *)jarg1;
13067   arg2 = (Dali::Vector4 *)jarg2;
13068   if (!arg2) {
13069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13070     return 0;
13071   }
13072   {
13073     try {
13074       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13075     } catch (std::out_of_range& e) {
13076       {
13077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13078       };
13079     } catch (std::exception& e) {
13080       {
13081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13082       };
13083     } catch (Dali::DaliException e) {
13084       {
13085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13086       };
13087     } catch (...) {
13088       {
13089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13090       };
13091     }
13092   }
13093
13094   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13095   return jresult;
13096 }
13097
13098
13099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13100   unsigned int jresult ;
13101   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13102   Dali::Matrix *arg2 = 0 ;
13103   bool result;
13104
13105   arg1 = (Dali::Matrix *)jarg1;
13106   arg2 = (Dali::Matrix *)jarg2;
13107   if (!arg2) {
13108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13109     return 0;
13110   }
13111   {
13112     try {
13113       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13114     } catch (std::out_of_range& e) {
13115       {
13116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13117       };
13118     } catch (std::exception& e) {
13119       {
13120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13121       };
13122     } catch (Dali::DaliException e) {
13123       {
13124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13125       };
13126     } catch (...) {
13127       {
13128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13129       };
13130     }
13131   }
13132
13133   jresult = result;
13134   return jresult;
13135 }
13136
13137
13138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13139   unsigned int jresult ;
13140   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13141   Dali::Matrix *arg2 = 0 ;
13142   bool result;
13143
13144   arg1 = (Dali::Matrix *)jarg1;
13145   arg2 = (Dali::Matrix *)jarg2;
13146   if (!arg2) {
13147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13148     return 0;
13149   }
13150   {
13151     try {
13152       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13153     } catch (std::out_of_range& e) {
13154       {
13155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13156       };
13157     } catch (std::exception& e) {
13158       {
13159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13160       };
13161     } catch (Dali::DaliException e) {
13162       {
13163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13164       };
13165     } catch (...) {
13166       {
13167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13168       };
13169     }
13170   }
13171
13172   jresult = result;
13173   return jresult;
13174 }
13175
13176
13177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13178   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13179   Dali::Vector3 *arg2 = 0 ;
13180   Dali::Quaternion *arg3 = 0 ;
13181   Dali::Vector3 *arg4 = 0 ;
13182
13183   arg1 = (Dali::Matrix *)jarg1;
13184   arg2 = (Dali::Vector3 *)jarg2;
13185   if (!arg2) {
13186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13187     return ;
13188   }
13189   arg3 = (Dali::Quaternion *)jarg3;
13190   if (!arg3) {
13191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13192     return ;
13193   }
13194   arg4 = (Dali::Vector3 *)jarg4;
13195   if (!arg4) {
13196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13197     return ;
13198   }
13199   {
13200     try {
13201       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13202     } catch (std::out_of_range& e) {
13203       {
13204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13205       };
13206     } catch (std::exception& e) {
13207       {
13208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13209       };
13210     } catch (Dali::DaliException e) {
13211       {
13212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13213       };
13214     } catch (...) {
13215       {
13216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13217       };
13218     }
13219   }
13220
13221 }
13222
13223
13224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13225   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13226   Dali::Vector3 *arg2 = 0 ;
13227   Dali::Quaternion *arg3 = 0 ;
13228   Dali::Vector3 *arg4 = 0 ;
13229
13230   arg1 = (Dali::Matrix *)jarg1;
13231   arg2 = (Dali::Vector3 *)jarg2;
13232   if (!arg2) {
13233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13234     return ;
13235   }
13236   arg3 = (Dali::Quaternion *)jarg3;
13237   if (!arg3) {
13238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13239     return ;
13240   }
13241   arg4 = (Dali::Vector3 *)jarg4;
13242   if (!arg4) {
13243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13244     return ;
13245   }
13246   {
13247     try {
13248       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13249     } catch (std::out_of_range& e) {
13250       {
13251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13252       };
13253     } catch (std::exception& e) {
13254       {
13255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13256       };
13257     } catch (Dali::DaliException e) {
13258       {
13259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13260       };
13261     } catch (...) {
13262       {
13263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13264       };
13265     }
13266   }
13267
13268 }
13269
13270
13271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13272   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13273   Dali::Vector3 *arg2 = 0 ;
13274   Dali::Vector3 *arg3 = 0 ;
13275   Dali::Vector3 *arg4 = 0 ;
13276   Dali::Vector3 *arg5 = 0 ;
13277
13278   arg1 = (Dali::Matrix *)jarg1;
13279   arg2 = (Dali::Vector3 *)jarg2;
13280   if (!arg2) {
13281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13282     return ;
13283   }
13284   arg3 = (Dali::Vector3 *)jarg3;
13285   if (!arg3) {
13286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13287     return ;
13288   }
13289   arg4 = (Dali::Vector3 *)jarg4;
13290   if (!arg4) {
13291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13292     return ;
13293   }
13294   arg5 = (Dali::Vector3 *)jarg5;
13295   if (!arg5) {
13296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13297     return ;
13298   }
13299   {
13300     try {
13301       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13302     } catch (std::out_of_range& e) {
13303       {
13304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13305       };
13306     } catch (std::exception& e) {
13307       {
13308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13309       };
13310     } catch (Dali::DaliException e) {
13311       {
13312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13313       };
13314     } catch (...) {
13315       {
13316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13317       };
13318     }
13319   }
13320
13321 }
13322
13323
13324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13325   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13326   Dali::Vector3 *arg2 = 0 ;
13327   Dali::Quaternion *arg3 = 0 ;
13328   Dali::Vector3 *arg4 = 0 ;
13329
13330   arg1 = (Dali::Matrix *)jarg1;
13331   arg2 = (Dali::Vector3 *)jarg2;
13332   if (!arg2) {
13333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13334     return ;
13335   }
13336   arg3 = (Dali::Quaternion *)jarg3;
13337   if (!arg3) {
13338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13339     return ;
13340   }
13341   arg4 = (Dali::Vector3 *)jarg4;
13342   if (!arg4) {
13343     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13344     return ;
13345   }
13346   {
13347     try {
13348       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13349     } catch (std::out_of_range& e) {
13350       {
13351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13352       };
13353     } catch (std::exception& e) {
13354       {
13355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13356       };
13357     } catch (Dali::DaliException e) {
13358       {
13359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13360       };
13361     } catch (...) {
13362       {
13363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13364       };
13365     }
13366   }
13367
13368 }
13369
13370
13371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13372   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13373
13374   arg1 = (Dali::Matrix *)jarg1;
13375   {
13376     try {
13377       delete arg1;
13378     } catch (std::out_of_range& e) {
13379       {
13380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13381       };
13382     } catch (std::exception& e) {
13383       {
13384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13385       };
13386     } catch (Dali::DaliException e) {
13387       {
13388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13389       };
13390     } catch (...) {
13391       {
13392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13393       };
13394     }
13395   }
13396
13397 }
13398
13399
13400 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13401   void * jresult ;
13402   Dali::Matrix3 *result = 0 ;
13403
13404   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13405   jresult = (void *)result;
13406   return jresult;
13407 }
13408
13409
13410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13411   void * jresult ;
13412   Dali::Matrix3 *result = 0 ;
13413
13414   {
13415     try {
13416       result = (Dali::Matrix3 *)new Dali::Matrix3();
13417     } catch (std::out_of_range& e) {
13418       {
13419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13420       };
13421     } catch (std::exception& e) {
13422       {
13423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13424       };
13425     } catch (Dali::DaliException e) {
13426       {
13427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13428       };
13429     } catch (...) {
13430       {
13431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13432       };
13433     }
13434   }
13435
13436   jresult = (void *)result;
13437   return jresult;
13438 }
13439
13440
13441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13442   void * jresult ;
13443   Dali::Matrix3 *arg1 = 0 ;
13444   Dali::Matrix3 *result = 0 ;
13445
13446   arg1 = (Dali::Matrix3 *)jarg1;
13447   if (!arg1) {
13448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13449     return 0;
13450   }
13451   {
13452     try {
13453       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13454     } catch (std::out_of_range& e) {
13455       {
13456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13457       };
13458     } catch (std::exception& e) {
13459       {
13460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13461       };
13462     } catch (Dali::DaliException e) {
13463       {
13464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13465       };
13466     } catch (...) {
13467       {
13468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13469       };
13470     }
13471   }
13472
13473   jresult = (void *)result;
13474   return jresult;
13475 }
13476
13477
13478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13479   void * jresult ;
13480   Dali::Matrix *arg1 = 0 ;
13481   Dali::Matrix3 *result = 0 ;
13482
13483   arg1 = (Dali::Matrix *)jarg1;
13484   if (!arg1) {
13485     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13486     return 0;
13487   }
13488   {
13489     try {
13490       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13491     } catch (std::out_of_range& e) {
13492       {
13493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13494       };
13495     } catch (std::exception& e) {
13496       {
13497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13498       };
13499     } catch (Dali::DaliException e) {
13500       {
13501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13502       };
13503     } catch (...) {
13504       {
13505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13506       };
13507     }
13508   }
13509
13510   jresult = (void *)result;
13511   return jresult;
13512 }
13513
13514
13515 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) {
13516   void * jresult ;
13517   float arg1 ;
13518   float arg2 ;
13519   float arg3 ;
13520   float arg4 ;
13521   float arg5 ;
13522   float arg6 ;
13523   float arg7 ;
13524   float arg8 ;
13525   float arg9 ;
13526   Dali::Matrix3 *result = 0 ;
13527
13528   arg1 = (float)jarg1;
13529   arg2 = (float)jarg2;
13530   arg3 = (float)jarg3;
13531   arg4 = (float)jarg4;
13532   arg5 = (float)jarg5;
13533   arg6 = (float)jarg6;
13534   arg7 = (float)jarg7;
13535   arg8 = (float)jarg8;
13536   arg9 = (float)jarg9;
13537   {
13538     try {
13539       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13540     } catch (std::out_of_range& e) {
13541       {
13542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13543       };
13544     } catch (std::exception& e) {
13545       {
13546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13547       };
13548     } catch (Dali::DaliException e) {
13549       {
13550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13551       };
13552     } catch (...) {
13553       {
13554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13555       };
13556     }
13557   }
13558
13559   jresult = (void *)result;
13560   return jresult;
13561 }
13562
13563
13564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13565   void * jresult ;
13566   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13567   Dali::Matrix3 *arg2 = 0 ;
13568   Dali::Matrix3 *result = 0 ;
13569
13570   arg1 = (Dali::Matrix3 *)jarg1;
13571   arg2 = (Dali::Matrix3 *)jarg2;
13572   if (!arg2) {
13573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13574     return 0;
13575   }
13576   {
13577     try {
13578       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13579     } catch (std::out_of_range& e) {
13580       {
13581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13582       };
13583     } catch (std::exception& e) {
13584       {
13585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13586       };
13587     } catch (Dali::DaliException e) {
13588       {
13589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13590       };
13591     } catch (...) {
13592       {
13593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13594       };
13595     }
13596   }
13597
13598   jresult = (void *)result;
13599   return jresult;
13600 }
13601
13602
13603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13604   void * jresult ;
13605   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13606   Dali::Matrix *arg2 = 0 ;
13607   Dali::Matrix3 *result = 0 ;
13608
13609   arg1 = (Dali::Matrix3 *)jarg1;
13610   arg2 = (Dali::Matrix *)jarg2;
13611   if (!arg2) {
13612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13613     return 0;
13614   }
13615   {
13616     try {
13617       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13618     } catch (std::out_of_range& e) {
13619       {
13620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13621       };
13622     } catch (std::exception& e) {
13623       {
13624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13625       };
13626     } catch (Dali::DaliException e) {
13627       {
13628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13629       };
13630     } catch (...) {
13631       {
13632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13633       };
13634     }
13635   }
13636
13637   jresult = (void *)result;
13638   return jresult;
13639 }
13640
13641
13642 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13643   unsigned int jresult ;
13644   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13645   Dali::Matrix3 *arg2 = 0 ;
13646   bool result;
13647
13648   arg1 = (Dali::Matrix3 *)jarg1;
13649   arg2 = (Dali::Matrix3 *)jarg2;
13650   if (!arg2) {
13651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13652     return 0;
13653   }
13654   {
13655     try {
13656       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13657     } catch (std::out_of_range& e) {
13658       {
13659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13660       };
13661     } catch (std::exception& e) {
13662       {
13663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13664       };
13665     } catch (Dali::DaliException e) {
13666       {
13667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13668       };
13669     } catch (...) {
13670       {
13671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13672       };
13673     }
13674   }
13675
13676   jresult = result;
13677   return jresult;
13678 }
13679
13680
13681 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13682   unsigned int jresult ;
13683   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13684   Dali::Matrix3 *arg2 = 0 ;
13685   bool result;
13686
13687   arg1 = (Dali::Matrix3 *)jarg1;
13688   arg2 = (Dali::Matrix3 *)jarg2;
13689   if (!arg2) {
13690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13691     return 0;
13692   }
13693   {
13694     try {
13695       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13696     } catch (std::out_of_range& e) {
13697       {
13698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13699       };
13700     } catch (std::exception& e) {
13701       {
13702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13703       };
13704     } catch (Dali::DaliException e) {
13705       {
13706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13707       };
13708     } catch (...) {
13709       {
13710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13711       };
13712     }
13713   }
13714
13715   jresult = result;
13716   return jresult;
13717 }
13718
13719
13720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13721   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13722
13723   arg1 = (Dali::Matrix3 *)jarg1;
13724   {
13725     try {
13726       delete arg1;
13727     } catch (std::out_of_range& e) {
13728       {
13729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13730       };
13731     } catch (std::exception& e) {
13732       {
13733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13734       };
13735     } catch (Dali::DaliException e) {
13736       {
13737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13738       };
13739     } catch (...) {
13740       {
13741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13742       };
13743     }
13744   }
13745
13746 }
13747
13748
13749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13750   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13751
13752   arg1 = (Dali::Matrix3 *)jarg1;
13753   {
13754     try {
13755       (arg1)->SetIdentity();
13756     } catch (std::out_of_range& e) {
13757       {
13758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13759       };
13760     } catch (std::exception& e) {
13761       {
13762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13763       };
13764     } catch (Dali::DaliException e) {
13765       {
13766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13767       };
13768     } catch (...) {
13769       {
13770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13771       };
13772     }
13773   }
13774
13775 }
13776
13777
13778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13779   void * jresult ;
13780   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13781   float *result = 0 ;
13782
13783   arg1 = (Dali::Matrix3 *)jarg1;
13784   {
13785     try {
13786       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13787     } catch (std::out_of_range& e) {
13788       {
13789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13790       };
13791     } catch (std::exception& e) {
13792       {
13793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13794       };
13795     } catch (Dali::DaliException e) {
13796       {
13797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13798       };
13799     } catch (...) {
13800       {
13801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13802       };
13803     }
13804   }
13805
13806   jresult = (void *)result;
13807   return jresult;
13808 }
13809
13810
13811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13812   unsigned int jresult ;
13813   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13814   bool result;
13815
13816   arg1 = (Dali::Matrix3 *)jarg1;
13817   {
13818     try {
13819       result = (bool)(arg1)->Invert();
13820     } catch (std::out_of_range& e) {
13821       {
13822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13823       };
13824     } catch (std::exception& e) {
13825       {
13826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13827       };
13828     } catch (Dali::DaliException e) {
13829       {
13830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13831       };
13832     } catch (...) {
13833       {
13834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13835       };
13836     }
13837   }
13838
13839   jresult = result;
13840   return jresult;
13841 }
13842
13843
13844 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13845   unsigned int jresult ;
13846   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13847   bool result;
13848
13849   arg1 = (Dali::Matrix3 *)jarg1;
13850   {
13851     try {
13852       result = (bool)(arg1)->Transpose();
13853     } catch (std::out_of_range& e) {
13854       {
13855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13856       };
13857     } catch (std::exception& e) {
13858       {
13859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13860       };
13861     } catch (Dali::DaliException e) {
13862       {
13863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13864       };
13865     } catch (...) {
13866       {
13867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13868       };
13869     }
13870   }
13871
13872   jresult = result;
13873   return jresult;
13874 }
13875
13876
13877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13878   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13879   float arg2 ;
13880
13881   arg1 = (Dali::Matrix3 *)jarg1;
13882   arg2 = (float)jarg2;
13883   {
13884     try {
13885       (arg1)->Scale(arg2);
13886     } catch (std::out_of_range& e) {
13887       {
13888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13889       };
13890     } catch (std::exception& e) {
13891       {
13892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13893       };
13894     } catch (Dali::DaliException e) {
13895       {
13896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13897       };
13898     } catch (...) {
13899       {
13900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13901       };
13902     }
13903   }
13904
13905 }
13906
13907
13908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13909   float jresult ;
13910   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13911   float result;
13912
13913   arg1 = (Dali::Matrix3 *)jarg1;
13914   {
13915     try {
13916       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13917     } catch (std::out_of_range& e) {
13918       {
13919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13920       };
13921     } catch (std::exception& e) {
13922       {
13923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13924       };
13925     } catch (Dali::DaliException e) {
13926       {
13927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13928       };
13929     } catch (...) {
13930       {
13931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13932       };
13933     }
13934   }
13935
13936   jresult = result;
13937   return jresult;
13938 }
13939
13940
13941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13942   unsigned int jresult ;
13943   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13944   bool result;
13945
13946   arg1 = (Dali::Matrix3 *)jarg1;
13947   {
13948     try {
13949       result = (bool)(arg1)->ScaledInverseTranspose();
13950     } catch (std::out_of_range& e) {
13951       {
13952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13953       };
13954     } catch (std::exception& e) {
13955       {
13956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13957       };
13958     } catch (Dali::DaliException e) {
13959       {
13960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13961       };
13962     } catch (...) {
13963       {
13964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13965       };
13966     }
13967   }
13968
13969   jresult = result;
13970   return jresult;
13971 }
13972
13973
13974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13975   Dali::Matrix3 *arg1 = 0 ;
13976   Dali::Matrix3 *arg2 = 0 ;
13977   Dali::Matrix3 *arg3 = 0 ;
13978
13979   arg1 = (Dali::Matrix3 *)jarg1;
13980   if (!arg1) {
13981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13982     return ;
13983   }
13984   arg2 = (Dali::Matrix3 *)jarg2;
13985   if (!arg2) {
13986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13987     return ;
13988   }
13989   arg3 = (Dali::Matrix3 *)jarg3;
13990   if (!arg3) {
13991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13992     return ;
13993   }
13994   {
13995     try {
13996       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13997     } catch (std::out_of_range& e) {
13998       {
13999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14000       };
14001     } catch (std::exception& e) {
14002       {
14003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14004       };
14005     } catch (Dali::DaliException e) {
14006       {
14007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14008       };
14009     } catch (...) {
14010       {
14011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14012       };
14013     }
14014   }
14015
14016 }
14017
14018
14019 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
14020   float jresult ;
14021   float arg1 ;
14022   float arg2 ;
14023   float result;
14024
14025   arg1 = (float)jarg1;
14026   arg2 = (float)jarg2;
14027   {
14028     try {
14029       result = (float)Dali::Random::Range(arg1,arg2);
14030     } catch (std::out_of_range& e) {
14031       {
14032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14033       };
14034     } catch (std::exception& e) {
14035       {
14036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14037       };
14038     } catch (Dali::DaliException e) {
14039       {
14040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14041       };
14042     } catch (...) {
14043       {
14044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14045       };
14046     }
14047   }
14048
14049   jresult = result;
14050   return jresult;
14051 }
14052
14053
14054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14055   void * jresult ;
14056   Dali::Vector4 result;
14057
14058   {
14059     try {
14060       result = Dali::Random::Axis();
14061     } catch (std::out_of_range& e) {
14062       {
14063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14064       };
14065     } catch (std::exception& e) {
14066       {
14067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14068       };
14069     } catch (Dali::DaliException e) {
14070       {
14071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14072       };
14073     } catch (...) {
14074       {
14075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14076       };
14077     }
14078   }
14079
14080   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14081   return jresult;
14082 }
14083
14084
14085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14086   void * jresult ;
14087   Dali::AngleAxis *result = 0 ;
14088
14089   {
14090     try {
14091       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14092     } catch (std::out_of_range& e) {
14093       {
14094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14095       };
14096     } catch (std::exception& e) {
14097       {
14098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14099       };
14100     } catch (Dali::DaliException e) {
14101       {
14102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14103       };
14104     } catch (...) {
14105       {
14106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14107       };
14108     }
14109   }
14110
14111   jresult = (void *)result;
14112   return jresult;
14113 }
14114
14115
14116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14117   void * jresult ;
14118   Dali::Radian arg1 ;
14119   Dali::Vector3 *arg2 = 0 ;
14120   Dali::Radian *argp1 ;
14121   Dali::AngleAxis *result = 0 ;
14122
14123   argp1 = (Dali::Radian *)jarg1;
14124   if (!argp1) {
14125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14126     return 0;
14127   }
14128   arg1 = *argp1;
14129   arg2 = (Dali::Vector3 *)jarg2;
14130   if (!arg2) {
14131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14132     return 0;
14133   }
14134   {
14135     try {
14136       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14137     } catch (std::out_of_range& e) {
14138       {
14139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14140       };
14141     } catch (std::exception& e) {
14142       {
14143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14144       };
14145     } catch (Dali::DaliException e) {
14146       {
14147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14148       };
14149     } catch (...) {
14150       {
14151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14152       };
14153     }
14154   }
14155
14156   jresult = (void *)result;
14157   return jresult;
14158 }
14159
14160
14161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14162   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14163   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14164
14165   arg1 = (Dali::AngleAxis *)jarg1;
14166   arg2 = (Dali::Radian *)jarg2;
14167   if (arg1) (arg1)->angle = *arg2;
14168 }
14169
14170
14171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14172   void * jresult ;
14173   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14174   Dali::Radian *result = 0 ;
14175
14176   arg1 = (Dali::AngleAxis *)jarg1;
14177   result = (Dali::Radian *)& ((arg1)->angle);
14178   jresult = (void *)result;
14179   return jresult;
14180 }
14181
14182
14183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14184   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14185   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14186
14187   arg1 = (Dali::AngleAxis *)jarg1;
14188   arg2 = (Dali::Vector3 *)jarg2;
14189   if (arg1) (arg1)->axis = *arg2;
14190 }
14191
14192
14193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14194   void * jresult ;
14195   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14196   Dali::Vector3 *result = 0 ;
14197
14198   arg1 = (Dali::AngleAxis *)jarg1;
14199   result = (Dali::Vector3 *)& ((arg1)->axis);
14200   jresult = (void *)result;
14201   return jresult;
14202 }
14203
14204
14205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14206   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14207
14208   arg1 = (Dali::AngleAxis *)jarg1;
14209   {
14210     try {
14211       delete arg1;
14212     } catch (std::out_of_range& e) {
14213       {
14214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14215       };
14216     } catch (std::exception& e) {
14217       {
14218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14219       };
14220     } catch (Dali::DaliException e) {
14221       {
14222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14223       };
14224     } catch (...) {
14225       {
14226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14227       };
14228     }
14229   }
14230
14231 }
14232
14233
14234 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14235   unsigned int jresult ;
14236   Dali::AngleAxis *arg1 = 0 ;
14237   Dali::AngleAxis *arg2 = 0 ;
14238   bool result;
14239
14240   arg1 = (Dali::AngleAxis *)jarg1;
14241   if (!arg1) {
14242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14243     return 0;
14244   }
14245   arg2 = (Dali::AngleAxis *)jarg2;
14246   if (!arg2) {
14247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14248     return 0;
14249   }
14250   {
14251     try {
14252       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14253     } catch (std::out_of_range& e) {
14254       {
14255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14256       };
14257     } catch (std::exception& e) {
14258       {
14259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14260       };
14261     } catch (Dali::DaliException e) {
14262       {
14263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14264       };
14265     } catch (...) {
14266       {
14267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14268       };
14269     }
14270   }
14271
14272   jresult = result;
14273   return jresult;
14274 }
14275
14276
14277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14278   unsigned int jresult ;
14279   unsigned int arg1 ;
14280   unsigned int result;
14281
14282   arg1 = (unsigned int)jarg1;
14283   {
14284     try {
14285       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14286     } catch (std::out_of_range& e) {
14287       {
14288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14289       };
14290     } catch (std::exception& e) {
14291       {
14292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14293       };
14294     } catch (Dali::DaliException e) {
14295       {
14296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14297       };
14298     } catch (...) {
14299       {
14300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14301       };
14302     }
14303   }
14304
14305   jresult = result;
14306   return jresult;
14307 }
14308
14309
14310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14311   unsigned int jresult ;
14312   unsigned int arg1 ;
14313   bool result;
14314
14315   arg1 = (unsigned int)jarg1;
14316   {
14317     try {
14318       result = (bool)Dali::IsPowerOfTwo(arg1);
14319     } catch (std::out_of_range& e) {
14320       {
14321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14322       };
14323     } catch (std::exception& e) {
14324       {
14325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14326       };
14327     } catch (Dali::DaliException e) {
14328       {
14329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14330       };
14331     } catch (...) {
14332       {
14333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14334       };
14335     }
14336   }
14337
14338   jresult = result;
14339   return jresult;
14340 }
14341
14342
14343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14344   float jresult ;
14345   float arg1 ;
14346   float arg2 ;
14347   float result;
14348
14349   arg1 = (float)jarg1;
14350   arg2 = (float)jarg2;
14351   {
14352     try {
14353       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14354     } catch (std::out_of_range& e) {
14355       {
14356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14357       };
14358     } catch (std::exception& e) {
14359       {
14360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14361       };
14362     } catch (Dali::DaliException e) {
14363       {
14364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14365       };
14366     } catch (...) {
14367       {
14368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14369       };
14370     }
14371   }
14372
14373   jresult = result;
14374   return jresult;
14375 }
14376
14377
14378 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14379   unsigned int jresult ;
14380   float arg1 ;
14381   bool result;
14382
14383   arg1 = (float)jarg1;
14384   {
14385     try {
14386       result = (bool)Dali::EqualsZero(arg1);
14387     } catch (std::out_of_range& e) {
14388       {
14389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14390       };
14391     } catch (std::exception& e) {
14392       {
14393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14394       };
14395     } catch (Dali::DaliException e) {
14396       {
14397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14398       };
14399     } catch (...) {
14400       {
14401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14402       };
14403     }
14404   }
14405
14406   jresult = result;
14407   return jresult;
14408 }
14409
14410
14411 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14412   unsigned int jresult ;
14413   float arg1 ;
14414   float arg2 ;
14415   bool result;
14416
14417   arg1 = (float)jarg1;
14418   arg2 = (float)jarg2;
14419   {
14420     try {
14421       result = (bool)Dali::Equals(arg1,arg2);
14422     } catch (std::out_of_range& e) {
14423       {
14424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14425       };
14426     } catch (std::exception& e) {
14427       {
14428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14429       };
14430     } catch (Dali::DaliException e) {
14431       {
14432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14433       };
14434     } catch (...) {
14435       {
14436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14437       };
14438     }
14439   }
14440
14441   jresult = result;
14442   return jresult;
14443 }
14444
14445
14446 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14447   unsigned int jresult ;
14448   float arg1 ;
14449   float arg2 ;
14450   float arg3 ;
14451   bool result;
14452
14453   arg1 = (float)jarg1;
14454   arg2 = (float)jarg2;
14455   arg3 = (float)jarg3;
14456   {
14457     try {
14458       result = (bool)Dali::Equals(arg1,arg2,arg3);
14459     } catch (std::out_of_range& e) {
14460       {
14461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14462       };
14463     } catch (std::exception& e) {
14464       {
14465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14466       };
14467     } catch (Dali::DaliException e) {
14468       {
14469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14470       };
14471     } catch (...) {
14472       {
14473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14474       };
14475     }
14476   }
14477
14478   jresult = result;
14479   return jresult;
14480 }
14481
14482
14483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14484   float jresult ;
14485   float arg1 ;
14486   int arg2 ;
14487   float result;
14488
14489   arg1 = (float)jarg1;
14490   arg2 = (int)jarg2;
14491   {
14492     try {
14493       result = (float)Dali::Round(arg1,arg2);
14494     } catch (std::out_of_range& e) {
14495       {
14496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14497       };
14498     } catch (std::exception& e) {
14499       {
14500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14501       };
14502     } catch (Dali::DaliException e) {
14503       {
14504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14505       };
14506     } catch (...) {
14507       {
14508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14509       };
14510     }
14511   }
14512
14513   jresult = result;
14514   return jresult;
14515 }
14516
14517
14518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14519   float jresult ;
14520   float arg1 ;
14521   float arg2 ;
14522   float arg3 ;
14523   float result;
14524
14525   arg1 = (float)jarg1;
14526   arg2 = (float)jarg2;
14527   arg3 = (float)jarg3;
14528   {
14529     try {
14530       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14531     } catch (std::out_of_range& e) {
14532       {
14533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14534       };
14535     } catch (std::exception& e) {
14536       {
14537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14538       };
14539     } catch (Dali::DaliException e) {
14540       {
14541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14542       };
14543     } catch (...) {
14544       {
14545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14546       };
14547     }
14548   }
14549
14550   jresult = result;
14551   return jresult;
14552 }
14553
14554
14555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14556   float jresult ;
14557   float arg1 ;
14558   float arg2 ;
14559   float arg3 ;
14560   float arg4 ;
14561   float result;
14562
14563   arg1 = (float)jarg1;
14564   arg2 = (float)jarg2;
14565   arg3 = (float)jarg3;
14566   arg4 = (float)jarg4;
14567   {
14568     try {
14569       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14570     } catch (std::out_of_range& e) {
14571       {
14572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14573       };
14574     } catch (std::exception& e) {
14575       {
14576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14577       };
14578     } catch (Dali::DaliException e) {
14579       {
14580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14581       };
14582     } catch (...) {
14583       {
14584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14585       };
14586     }
14587   }
14588
14589   jresult = result;
14590   return jresult;
14591 }
14592
14593
14594 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14595   int jresult ;
14596   int result;
14597
14598   result = (int)(int)Dali::Property::INVALID_INDEX;
14599   jresult = result;
14600   return jresult;
14601 }
14602
14603
14604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14605   int jresult ;
14606   int result;
14607
14608   result = (int)(int)Dali::Property::INVALID_KEY;
14609   jresult = result;
14610   return jresult;
14611 }
14612
14613
14614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14615   int jresult ;
14616   int result;
14617
14618   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14619   jresult = result;
14620   return jresult;
14621 }
14622
14623
14624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14625   void * jresult ;
14626   Dali::Handle *arg1 = 0 ;
14627   Dali::Property::Index arg2 ;
14628   Dali::Property *result = 0 ;
14629
14630   arg1 = (Dali::Handle *)jarg1;
14631   if (!arg1) {
14632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14633     return 0;
14634   }
14635   arg2 = (Dali::Property::Index)jarg2;
14636   {
14637     try {
14638       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14639     } catch (std::out_of_range& e) {
14640       {
14641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14642       };
14643     } catch (std::exception& e) {
14644       {
14645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14646       };
14647     } catch (Dali::DaliException e) {
14648       {
14649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14650       };
14651     } catch (...) {
14652       {
14653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14654       };
14655     }
14656   }
14657
14658   jresult = (void *)result;
14659   return jresult;
14660 }
14661
14662
14663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14664   void * jresult ;
14665   Dali::Handle *arg1 = 0 ;
14666   Dali::Property::Index arg2 ;
14667   int arg3 ;
14668   Dali::Property *result = 0 ;
14669
14670   arg1 = (Dali::Handle *)jarg1;
14671   if (!arg1) {
14672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14673     return 0;
14674   }
14675   arg2 = (Dali::Property::Index)jarg2;
14676   arg3 = (int)jarg3;
14677   {
14678     try {
14679       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14680     } catch (std::out_of_range& e) {
14681       {
14682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14683       };
14684     } catch (std::exception& e) {
14685       {
14686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14687       };
14688     } catch (Dali::DaliException e) {
14689       {
14690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14691       };
14692     } catch (...) {
14693       {
14694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14695       };
14696     }
14697   }
14698
14699   jresult = (void *)result;
14700   return jresult;
14701 }
14702
14703
14704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14705   void * jresult ;
14706   Dali::Handle *arg1 = 0 ;
14707   std::string *arg2 = 0 ;
14708   Dali::Property *result = 0 ;
14709
14710   arg1 = (Dali::Handle *)jarg1;
14711   if (!arg1) {
14712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14713     return 0;
14714   }
14715   if (!jarg2) {
14716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14717     return 0;
14718   }
14719   std::string arg2_str(jarg2);
14720   arg2 = &arg2_str;
14721   {
14722     try {
14723       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14724     } catch (std::out_of_range& e) {
14725       {
14726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14727       };
14728     } catch (std::exception& e) {
14729       {
14730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14731       };
14732     } catch (Dali::DaliException e) {
14733       {
14734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14735       };
14736     } catch (...) {
14737       {
14738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14739       };
14740     }
14741   }
14742
14743   jresult = (void *)result;
14744
14745   //argout typemap for const std::string&
14746
14747   return jresult;
14748 }
14749
14750
14751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14752   void * jresult ;
14753   Dali::Handle *arg1 = 0 ;
14754   std::string *arg2 = 0 ;
14755   int arg3 ;
14756   Dali::Property *result = 0 ;
14757
14758   arg1 = (Dali::Handle *)jarg1;
14759   if (!arg1) {
14760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14761     return 0;
14762   }
14763   if (!jarg2) {
14764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14765     return 0;
14766   }
14767   std::string arg2_str(jarg2);
14768   arg2 = &arg2_str;
14769   arg3 = (int)jarg3;
14770   {
14771     try {
14772       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14773     } catch (std::out_of_range& e) {
14774       {
14775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14776       };
14777     } catch (std::exception& e) {
14778       {
14779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14780       };
14781     } catch (Dali::DaliException e) {
14782       {
14783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14784       };
14785     } catch (...) {
14786       {
14787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14788       };
14789     }
14790   }
14791
14792   jresult = (void *)result;
14793
14794   //argout typemap for const std::string&
14795
14796   return jresult;
14797 }
14798
14799
14800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14801   Dali::Property *arg1 = (Dali::Property *) 0 ;
14802
14803   arg1 = (Dali::Property *)jarg1;
14804   {
14805     try {
14806       delete arg1;
14807     } catch (std::out_of_range& e) {
14808       {
14809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14810       };
14811     } catch (std::exception& e) {
14812       {
14813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14814       };
14815     } catch (Dali::DaliException e) {
14816       {
14817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14818       };
14819     } catch (...) {
14820       {
14821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14822       };
14823     }
14824   }
14825
14826 }
14827
14828
14829 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14830   Dali::Property *arg1 = (Dali::Property *) 0 ;
14831   Dali::Handle *arg2 = 0 ;
14832
14833   arg1 = (Dali::Property *)jarg1;
14834   arg2 = (Dali::Handle *)jarg2;
14835   if (!arg2) {
14836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14837     return ;
14838   }
14839   if (arg1) (arg1)->object = *arg2;
14840 }
14841
14842
14843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14844   void * jresult ;
14845   Dali::Property *arg1 = (Dali::Property *) 0 ;
14846   Dali::Handle *result = 0 ;
14847
14848   arg1 = (Dali::Property *)jarg1;
14849   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14850   jresult = (void *)result;
14851   return jresult;
14852 }
14853
14854
14855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14856   Dali::Property *arg1 = (Dali::Property *) 0 ;
14857   Dali::Property::Index arg2 ;
14858
14859   arg1 = (Dali::Property *)jarg1;
14860   arg2 = (Dali::Property::Index)jarg2;
14861   if (arg1) (arg1)->propertyIndex = arg2;
14862 }
14863
14864
14865 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14866   int jresult ;
14867   Dali::Property *arg1 = (Dali::Property *) 0 ;
14868   Dali::Property::Index result;
14869
14870   arg1 = (Dali::Property *)jarg1;
14871   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14872   jresult = result;
14873   return jresult;
14874 }
14875
14876
14877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14878   Dali::Property *arg1 = (Dali::Property *) 0 ;
14879   int arg2 ;
14880
14881   arg1 = (Dali::Property *)jarg1;
14882   arg2 = (int)jarg2;
14883   if (arg1) (arg1)->componentIndex = arg2;
14884 }
14885
14886
14887 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14888   int jresult ;
14889   Dali::Property *arg1 = (Dali::Property *) 0 ;
14890   int result;
14891
14892   arg1 = (Dali::Property *)jarg1;
14893   result = (int) ((arg1)->componentIndex);
14894   jresult = result;
14895   return jresult;
14896 }
14897
14898
14899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14900   void * jresult ;
14901   Dali::Property::Array *result = 0 ;
14902
14903   {
14904     try {
14905       result = (Dali::Property::Array *)new Dali::Property::Array();
14906     } catch (std::out_of_range& e) {
14907       {
14908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14909       };
14910     } catch (std::exception& e) {
14911       {
14912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14913       };
14914     } catch (Dali::DaliException e) {
14915       {
14916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14917       };
14918     } catch (...) {
14919       {
14920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14921       };
14922     }
14923   }
14924
14925   jresult = (void *)result;
14926   return jresult;
14927 }
14928
14929
14930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14931   void * jresult ;
14932   Dali::Property::Array *arg1 = 0 ;
14933   Dali::Property::Array *result = 0 ;
14934
14935   arg1 = (Dali::Property::Array *)jarg1;
14936   if (!arg1) {
14937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14938     return 0;
14939   }
14940   {
14941     try {
14942       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14943     } catch (std::out_of_range& e) {
14944       {
14945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14946       };
14947     } catch (std::exception& e) {
14948       {
14949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14950       };
14951     } catch (Dali::DaliException e) {
14952       {
14953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14954       };
14955     } catch (...) {
14956       {
14957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14958       };
14959     }
14960   }
14961
14962   jresult = (void *)result;
14963   return jresult;
14964 }
14965
14966
14967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14968   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14969
14970   arg1 = (Dali::Property::Array *)jarg1;
14971   {
14972     try {
14973       delete arg1;
14974     } catch (std::out_of_range& e) {
14975       {
14976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14977       };
14978     } catch (std::exception& e) {
14979       {
14980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14981       };
14982     } catch (Dali::DaliException e) {
14983       {
14984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14985       };
14986     } catch (...) {
14987       {
14988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14989       };
14990     }
14991   }
14992
14993 }
14994
14995
14996 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14997   unsigned long jresult ;
14998   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14999   Dali::Property::Array::SizeType result;
15000
15001   arg1 = (Dali::Property::Array *)jarg1;
15002   {
15003     try {
15004       result = ((Dali::Property::Array const *)arg1)->Size();
15005     } catch (std::out_of_range& e) {
15006       {
15007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15008       };
15009     } catch (std::exception& e) {
15010       {
15011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15012       };
15013     } catch (Dali::DaliException e) {
15014       {
15015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15016       };
15017     } catch (...) {
15018       {
15019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15020       };
15021     }
15022   }
15023
15024   jresult = (unsigned long)result;
15025   return jresult;
15026 }
15027
15028
15029 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
15030   unsigned long jresult ;
15031   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15032   Dali::Property::Array::SizeType result;
15033
15034   arg1 = (Dali::Property::Array *)jarg1;
15035   {
15036     try {
15037       result = ((Dali::Property::Array const *)arg1)->Count();
15038     } catch (std::out_of_range& e) {
15039       {
15040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15041       };
15042     } catch (std::exception& e) {
15043       {
15044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15045       };
15046     } catch (Dali::DaliException e) {
15047       {
15048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15049       };
15050     } catch (...) {
15051       {
15052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15053       };
15054     }
15055   }
15056
15057   jresult = (unsigned long)result;
15058   return jresult;
15059 }
15060
15061
15062 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15063   unsigned int jresult ;
15064   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15065   bool result;
15066
15067   arg1 = (Dali::Property::Array *)jarg1;
15068   {
15069     try {
15070       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15071     } catch (std::out_of_range& e) {
15072       {
15073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15074       };
15075     } catch (std::exception& e) {
15076       {
15077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15078       };
15079     } catch (Dali::DaliException e) {
15080       {
15081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15082       };
15083     } catch (...) {
15084       {
15085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15086       };
15087     }
15088   }
15089
15090   jresult = result;
15091   return jresult;
15092 }
15093
15094
15095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15096   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15097
15098   arg1 = (Dali::Property::Array *)jarg1;
15099   {
15100     try {
15101       (arg1)->Clear();
15102     } catch (std::out_of_range& e) {
15103       {
15104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15105       };
15106     } catch (std::exception& e) {
15107       {
15108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15109       };
15110     } catch (Dali::DaliException e) {
15111       {
15112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15113       };
15114     } catch (...) {
15115       {
15116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15117       };
15118     }
15119   }
15120
15121 }
15122
15123
15124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15125   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15126   Dali::Property::Array::SizeType arg2 ;
15127
15128   arg1 = (Dali::Property::Array *)jarg1;
15129   arg2 = (Dali::Property::Array::SizeType)jarg2;
15130   {
15131     try {
15132       (arg1)->Reserve(arg2);
15133     } catch (std::out_of_range& e) {
15134       {
15135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15136       };
15137     } catch (std::exception& e) {
15138       {
15139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15140       };
15141     } catch (Dali::DaliException e) {
15142       {
15143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15144       };
15145     } catch (...) {
15146       {
15147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15148       };
15149     }
15150   }
15151
15152 }
15153
15154
15155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15156   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15157   Dali::Property::Array::SizeType arg2 ;
15158
15159   arg1 = (Dali::Property::Array *)jarg1;
15160   arg2 = (Dali::Property::Array::SizeType)jarg2;
15161   {
15162     try {
15163       (arg1)->Resize(arg2);
15164     } catch (std::out_of_range& e) {
15165       {
15166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15167       };
15168     } catch (std::exception& e) {
15169       {
15170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15171       };
15172     } catch (Dali::DaliException e) {
15173       {
15174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15175       };
15176     } catch (...) {
15177       {
15178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15179       };
15180     }
15181   }
15182
15183 }
15184
15185
15186 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15187   unsigned long jresult ;
15188   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15189   Dali::Property::Array::SizeType result;
15190
15191   arg1 = (Dali::Property::Array *)jarg1;
15192   {
15193     try {
15194       result = (arg1)->Capacity();
15195     } catch (std::out_of_range& e) {
15196       {
15197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15198       };
15199     } catch (std::exception& e) {
15200       {
15201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15202       };
15203     } catch (Dali::DaliException e) {
15204       {
15205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15206       };
15207     } catch (...) {
15208       {
15209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15210       };
15211     }
15212   }
15213
15214   jresult = (unsigned long)result;
15215   return jresult;
15216 }
15217
15218
15219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15220   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15221   Dali::Property::Value *arg2 = 0 ;
15222
15223   arg1 = (Dali::Property::Array *)jarg1;
15224   arg2 = (Dali::Property::Value *)jarg2;
15225   if (!arg2) {
15226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15227     return ;
15228   }
15229   {
15230     try {
15231       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15232     } catch (std::out_of_range& e) {
15233       {
15234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15235       };
15236     } catch (std::exception& e) {
15237       {
15238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15239       };
15240     } catch (Dali::DaliException e) {
15241       {
15242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15243       };
15244     } catch (...) {
15245       {
15246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15247       };
15248     }
15249   }
15250
15251 }
15252
15253
15254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15255   void * jresult ;
15256   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15257   Dali::Property::Value *arg2 = 0 ;
15258   Dali::Property::Array *result = 0 ;
15259
15260   arg1 = (Dali::Property::Array *)jarg1;
15261   arg2 = (Dali::Property::Value *)jarg2;
15262   if (!arg2) {
15263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15264     return 0;
15265   }
15266   {
15267     try {
15268       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15269     } catch (std::out_of_range& e) {
15270       {
15271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15272       };
15273     } catch (std::exception& e) {
15274       {
15275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15276       };
15277     } catch (Dali::DaliException e) {
15278       {
15279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15280       };
15281     } catch (...) {
15282       {
15283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15284       };
15285     }
15286   }
15287
15288   jresult = (void *)result;
15289   return jresult;
15290 }
15291
15292
15293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15294   void * jresult ;
15295   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15296   Dali::Property::Array::SizeType arg2 ;
15297   Dali::Property::Value *result = 0 ;
15298
15299   arg1 = (Dali::Property::Array *)jarg1;
15300   arg2 = (Dali::Property::Array::SizeType)jarg2;
15301   {
15302     try {
15303       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15304     } catch (std::out_of_range& e) {
15305       {
15306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15307       };
15308     } catch (std::exception& e) {
15309       {
15310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15311       };
15312     } catch (Dali::DaliException e) {
15313       {
15314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15315       };
15316     } catch (...) {
15317       {
15318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15319       };
15320     }
15321   }
15322
15323   jresult = (void *)result;
15324   return jresult;
15325 }
15326
15327
15328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15329   void * jresult ;
15330   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15331   Dali::Property::Array::SizeType arg2 ;
15332   Dali::Property::Value *result = 0 ;
15333
15334   arg1 = (Dali::Property::Array *)jarg1;
15335   arg2 = (Dali::Property::Array::SizeType)jarg2;
15336   {
15337     try {
15338       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15339     } catch (std::out_of_range& e) {
15340       {
15341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15342       };
15343     } catch (std::exception& e) {
15344       {
15345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15346       };
15347     } catch (Dali::DaliException e) {
15348       {
15349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15350       };
15351     } catch (...) {
15352       {
15353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15354       };
15355     }
15356   }
15357
15358   jresult = (void *)result;
15359   return jresult;
15360 }
15361
15362
15363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15364   void * jresult ;
15365   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15366   Dali::Property::Array *arg2 = 0 ;
15367   Dali::Property::Array *result = 0 ;
15368
15369   arg1 = (Dali::Property::Array *)jarg1;
15370   arg2 = (Dali::Property::Array *)jarg2;
15371   if (!arg2) {
15372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15373     return 0;
15374   }
15375   {
15376     try {
15377       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15378     } catch (std::out_of_range& e) {
15379       {
15380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15381       };
15382     } catch (std::exception& e) {
15383       {
15384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15385       };
15386     } catch (Dali::DaliException e) {
15387       {
15388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15389       };
15390     } catch (...) {
15391       {
15392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15393       };
15394     }
15395   }
15396
15397   jresult = (void *)result;
15398   return jresult;
15399 }
15400
15401
15402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15403   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15404   enum Dali::Property::Key::Type arg2 ;
15405
15406   arg1 = (Dali::Property::Key *)jarg1;
15407   arg2 = (enum Dali::Property::Key::Type)jarg2;
15408   if (arg1) (arg1)->type = arg2;
15409 }
15410
15411
15412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15413   int jresult ;
15414   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15415   enum Dali::Property::Key::Type result;
15416
15417   arg1 = (Dali::Property::Key *)jarg1;
15418   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15419   jresult = (int)result;
15420   return jresult;
15421 }
15422
15423
15424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15425   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15426   Dali::Property::Index arg2 ;
15427
15428   arg1 = (Dali::Property::Key *)jarg1;
15429   arg2 = (Dali::Property::Index)jarg2;
15430   if (arg1) (arg1)->indexKey = arg2;
15431 }
15432
15433
15434 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15435   int jresult ;
15436   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15437   Dali::Property::Index result;
15438
15439   arg1 = (Dali::Property::Key *)jarg1;
15440   result = (Dali::Property::Index) ((arg1)->indexKey);
15441   jresult = result;
15442   return jresult;
15443 }
15444
15445
15446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15447   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15448   std::string *arg2 = 0 ;
15449
15450   arg1 = (Dali::Property::Key *)jarg1;
15451   if (!jarg2) {
15452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15453     return ;
15454   }
15455   std::string arg2_str(jarg2);
15456   arg2 = &arg2_str;
15457   if (arg1) (arg1)->stringKey = *arg2;
15458
15459   //argout typemap for const std::string&
15460
15461 }
15462
15463
15464 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15465   char * jresult ;
15466   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15467   std::string *result = 0 ;
15468
15469   arg1 = (Dali::Property::Key *)jarg1;
15470   result = (std::string *) & ((arg1)->stringKey);
15471   jresult = SWIG_csharp_string_callback(result->c_str());
15472   return jresult;
15473 }
15474
15475
15476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15477   void * jresult ;
15478   std::string *arg1 = 0 ;
15479   Dali::Property::Key *result = 0 ;
15480
15481   if (!jarg1) {
15482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15483     return 0;
15484   }
15485   std::string arg1_str(jarg1);
15486   arg1 = &arg1_str;
15487   {
15488     try {
15489       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15490     } catch (std::out_of_range& e) {
15491       {
15492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15493       };
15494     } catch (std::exception& e) {
15495       {
15496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15497       };
15498     } catch (Dali::DaliException e) {
15499       {
15500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15501       };
15502     } catch (...) {
15503       {
15504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15505       };
15506     }
15507   }
15508
15509   jresult = (void *)result;
15510
15511   //argout typemap for const std::string&
15512
15513   return jresult;
15514 }
15515
15516
15517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15518   void * jresult ;
15519   Dali::Property::Index arg1 ;
15520   Dali::Property::Key *result = 0 ;
15521
15522   arg1 = (Dali::Property::Index)jarg1;
15523   {
15524     try {
15525       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15526     } catch (std::out_of_range& e) {
15527       {
15528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15529       };
15530     } catch (std::exception& e) {
15531       {
15532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15533       };
15534     } catch (Dali::DaliException e) {
15535       {
15536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15537       };
15538     } catch (...) {
15539       {
15540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15541       };
15542     }
15543   }
15544
15545   jresult = (void *)result;
15546   return jresult;
15547 }
15548
15549
15550 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15551   unsigned int jresult ;
15552   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15553   std::string *arg2 = 0 ;
15554   bool result;
15555
15556   arg1 = (Dali::Property::Key *)jarg1;
15557   if (!jarg2) {
15558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15559     return 0;
15560   }
15561   std::string arg2_str(jarg2);
15562   arg2 = &arg2_str;
15563   {
15564     try {
15565       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15566     } catch (std::out_of_range& e) {
15567       {
15568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15569       };
15570     } catch (std::exception& e) {
15571       {
15572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15573       };
15574     } catch (Dali::DaliException e) {
15575       {
15576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15577       };
15578     } catch (...) {
15579       {
15580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15581       };
15582     }
15583   }
15584
15585   jresult = result;
15586
15587   //argout typemap for const std::string&
15588
15589   return jresult;
15590 }
15591
15592
15593 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15594   unsigned int jresult ;
15595   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15596   Dali::Property::Index arg2 ;
15597   bool result;
15598
15599   arg1 = (Dali::Property::Key *)jarg1;
15600   arg2 = (Dali::Property::Index)jarg2;
15601   {
15602     try {
15603       result = (bool)(arg1)->operator ==(arg2);
15604     } catch (std::out_of_range& e) {
15605       {
15606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15607       };
15608     } catch (std::exception& e) {
15609       {
15610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15611       };
15612     } catch (Dali::DaliException e) {
15613       {
15614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15615       };
15616     } catch (...) {
15617       {
15618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15619       };
15620     }
15621   }
15622
15623   jresult = result;
15624   return jresult;
15625 }
15626
15627
15628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15629   unsigned int jresult ;
15630   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15631   Dali::Property::Key *arg2 = 0 ;
15632   bool result;
15633
15634   arg1 = (Dali::Property::Key *)jarg1;
15635   arg2 = (Dali::Property::Key *)jarg2;
15636   if (!arg2) {
15637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15638     return 0;
15639   }
15640   {
15641     try {
15642       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15643     } catch (std::out_of_range& e) {
15644       {
15645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15646       };
15647     } catch (std::exception& e) {
15648       {
15649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15650       };
15651     } catch (Dali::DaliException e) {
15652       {
15653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15654       };
15655     } catch (...) {
15656       {
15657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15658       };
15659     }
15660   }
15661
15662   jresult = result;
15663   return jresult;
15664 }
15665
15666
15667 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15668   unsigned int jresult ;
15669   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15670   std::string *arg2 = 0 ;
15671   bool result;
15672
15673   arg1 = (Dali::Property::Key *)jarg1;
15674   if (!jarg2) {
15675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15676     return 0;
15677   }
15678   std::string arg2_str(jarg2);
15679   arg2 = &arg2_str;
15680   {
15681     try {
15682       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15683     } catch (std::out_of_range& e) {
15684       {
15685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15686       };
15687     } catch (std::exception& e) {
15688       {
15689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15690       };
15691     } catch (Dali::DaliException e) {
15692       {
15693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15694       };
15695     } catch (...) {
15696       {
15697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15698       };
15699     }
15700   }
15701
15702   jresult = result;
15703
15704   //argout typemap for const std::string&
15705
15706   return jresult;
15707 }
15708
15709
15710 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15711   unsigned int jresult ;
15712   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15713   Dali::Property::Index arg2 ;
15714   bool result;
15715
15716   arg1 = (Dali::Property::Key *)jarg1;
15717   arg2 = (Dali::Property::Index)jarg2;
15718   {
15719     try {
15720       result = (bool)(arg1)->operator !=(arg2);
15721     } catch (std::out_of_range& e) {
15722       {
15723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15724       };
15725     } catch (std::exception& e) {
15726       {
15727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15728       };
15729     } catch (Dali::DaliException e) {
15730       {
15731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15732       };
15733     } catch (...) {
15734       {
15735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15736       };
15737     }
15738   }
15739
15740   jresult = result;
15741   return jresult;
15742 }
15743
15744
15745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15746   unsigned int jresult ;
15747   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15748   Dali::Property::Key *arg2 = 0 ;
15749   bool result;
15750
15751   arg1 = (Dali::Property::Key *)jarg1;
15752   arg2 = (Dali::Property::Key *)jarg2;
15753   if (!arg2) {
15754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15755     return 0;
15756   }
15757   {
15758     try {
15759       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15760     } catch (std::out_of_range& e) {
15761       {
15762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15763       };
15764     } catch (std::exception& e) {
15765       {
15766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15767       };
15768     } catch (Dali::DaliException e) {
15769       {
15770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15771       };
15772     } catch (...) {
15773       {
15774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15775       };
15776     }
15777   }
15778
15779   jresult = result;
15780   return jresult;
15781 }
15782
15783
15784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15785   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15786
15787   arg1 = (Dali::Property::Key *)jarg1;
15788   {
15789     try {
15790       delete arg1;
15791     } catch (std::out_of_range& e) {
15792       {
15793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15794       };
15795     } catch (std::exception& e) {
15796       {
15797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15798       };
15799     } catch (Dali::DaliException e) {
15800       {
15801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15802       };
15803     } catch (...) {
15804       {
15805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15806       };
15807     }
15808   }
15809
15810 }
15811
15812
15813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15814   void * jresult ;
15815   Dali::Property::Map *result = 0 ;
15816
15817   {
15818     try {
15819       result = (Dali::Property::Map *)new Dali::Property::Map();
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 (Dali::DaliException e) {
15829       {
15830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15831       };
15832     } catch (...) {
15833       {
15834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15835       };
15836     }
15837   }
15838
15839   jresult = (void *)result;
15840   return jresult;
15841 }
15842
15843
15844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15845   void * jresult ;
15846   Dali::Property::Map *arg1 = 0 ;
15847   Dali::Property::Map *result = 0 ;
15848
15849   arg1 = (Dali::Property::Map *)jarg1;
15850   if (!arg1) {
15851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15852     return 0;
15853   }
15854   {
15855     try {
15856       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15857     } catch (std::out_of_range& e) {
15858       {
15859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15860       };
15861     } catch (std::exception& e) {
15862       {
15863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15864       };
15865     } catch (Dali::DaliException e) {
15866       {
15867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15868       };
15869     } catch (...) {
15870       {
15871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15872       };
15873     }
15874   }
15875
15876   jresult = (void *)result;
15877   return jresult;
15878 }
15879
15880
15881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15882   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15883
15884   arg1 = (Dali::Property::Map *)jarg1;
15885   {
15886     try {
15887       delete arg1;
15888     } catch (std::out_of_range& e) {
15889       {
15890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15891       };
15892     } catch (std::exception& e) {
15893       {
15894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15895       };
15896     } catch (Dali::DaliException e) {
15897       {
15898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15899       };
15900     } catch (...) {
15901       {
15902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15903       };
15904     }
15905   }
15906
15907 }
15908
15909
15910 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15911   unsigned long jresult ;
15912   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15913   Dali::Property::Map::SizeType result;
15914
15915   arg1 = (Dali::Property::Map *)jarg1;
15916   {
15917     try {
15918       result = ((Dali::Property::Map const *)arg1)->Count();
15919     } catch (std::out_of_range& e) {
15920       {
15921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15922       };
15923     } catch (std::exception& e) {
15924       {
15925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15926       };
15927     } catch (Dali::DaliException e) {
15928       {
15929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15930       };
15931     } catch (...) {
15932       {
15933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15934       };
15935     }
15936   }
15937
15938   jresult = (unsigned long)result;
15939   return jresult;
15940 }
15941
15942
15943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15944   unsigned int jresult ;
15945   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15946   bool result;
15947
15948   arg1 = (Dali::Property::Map *)jarg1;
15949   {
15950     try {
15951       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15952     } catch (std::out_of_range& e) {
15953       {
15954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15955       };
15956     } catch (std::exception& e) {
15957       {
15958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15959       };
15960     } catch (Dali::DaliException e) {
15961       {
15962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15963       };
15964     } catch (...) {
15965       {
15966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15967       };
15968     }
15969   }
15970
15971   jresult = result;
15972   return jresult;
15973 }
15974
15975
15976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15977   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15978   char *arg2 = (char *) 0 ;
15979   Dali::Property::Value *arg3 = 0 ;
15980
15981   arg1 = (Dali::Property::Map *)jarg1;
15982   arg2 = (char *)jarg2;
15983   arg3 = (Dali::Property::Value *)jarg3;
15984   if (!arg3) {
15985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15986     return ;
15987   }
15988   {
15989     try {
15990       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15991     } catch (std::out_of_range& e) {
15992       {
15993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15994       };
15995     } catch (std::exception& e) {
15996       {
15997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15998       };
15999     } catch (Dali::DaliException e) {
16000       {
16001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16002       };
16003     } catch (...) {
16004       {
16005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16006       };
16007     }
16008   }
16009
16010 }
16011
16012
16013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16014   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16015   Dali::Property::Index arg2 ;
16016   Dali::Property::Value *arg3 = 0 ;
16017
16018   arg1 = (Dali::Property::Map *)jarg1;
16019   arg2 = (Dali::Property::Index)jarg2;
16020   arg3 = (Dali::Property::Value *)jarg3;
16021   if (!arg3) {
16022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16023     return ;
16024   }
16025   {
16026     try {
16027       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
16028     } catch (std::out_of_range& e) {
16029       {
16030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16031       };
16032     } catch (std::exception& e) {
16033       {
16034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16035       };
16036     } catch (Dali::DaliException e) {
16037       {
16038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16039       };
16040     } catch (...) {
16041       {
16042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16043       };
16044     }
16045   }
16046
16047 }
16048
16049
16050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
16051   void * jresult ;
16052   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16053   char *arg2 = (char *) 0 ;
16054   Dali::Property::Value *arg3 = 0 ;
16055   Dali::Property::Map *result = 0 ;
16056
16057   arg1 = (Dali::Property::Map *)jarg1;
16058   arg2 = (char *)jarg2;
16059   arg3 = (Dali::Property::Value *)jarg3;
16060   if (!arg3) {
16061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16062     return 0;
16063   }
16064   {
16065     try {
16066       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16067     } catch (std::out_of_range& e) {
16068       {
16069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16070       };
16071     } catch (std::exception& e) {
16072       {
16073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16074       };
16075     } catch (Dali::DaliException e) {
16076       {
16077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16078       };
16079     } catch (...) {
16080       {
16081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16082       };
16083     }
16084   }
16085
16086   jresult = (void *)result;
16087   return jresult;
16088 }
16089
16090
16091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16092   void * jresult ;
16093   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16094   Dali::Property::Index arg2 ;
16095   Dali::Property::Value *arg3 = 0 ;
16096   Dali::Property::Map *result = 0 ;
16097
16098   arg1 = (Dali::Property::Map *)jarg1;
16099   arg2 = (Dali::Property::Index)jarg2;
16100   arg3 = (Dali::Property::Value *)jarg3;
16101   if (!arg3) {
16102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16103     return 0;
16104   }
16105   {
16106     try {
16107       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16108     } catch (std::out_of_range& e) {
16109       {
16110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16111       };
16112     } catch (std::exception& e) {
16113       {
16114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16115       };
16116     } catch (Dali::DaliException e) {
16117       {
16118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16119       };
16120     } catch (...) {
16121       {
16122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16123       };
16124     }
16125   }
16126
16127   jresult = (void *)result;
16128   return jresult;
16129 }
16130
16131
16132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16133   void * jresult ;
16134   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16135   Dali::Property::Map::SizeType arg2 ;
16136   Dali::Property::Value *result = 0 ;
16137
16138   arg1 = (Dali::Property::Map *)jarg1;
16139   arg2 = (Dali::Property::Map::SizeType)jarg2;
16140   {
16141     try {
16142       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16143     } catch (std::out_of_range& e) {
16144       {
16145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16146       };
16147     } catch (std::exception& e) {
16148       {
16149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16150       };
16151     } catch (Dali::DaliException e) {
16152       {
16153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16154       };
16155     } catch (...) {
16156       {
16157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16158       };
16159     }
16160   }
16161
16162   jresult = (void *)result;
16163   return jresult;
16164 }
16165
16166
16167 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16168   char * jresult ;
16169   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16170   Dali::Property::Map::SizeType arg2 ;
16171   std::string *result = 0 ;
16172
16173   arg1 = (Dali::Property::Map *)jarg1;
16174   arg2 = (Dali::Property::Map::SizeType)jarg2;
16175   {
16176     try {
16177       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16178     } catch (std::out_of_range& e) {
16179       {
16180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16181       };
16182     } catch (std::exception& e) {
16183       {
16184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16185       };
16186     } catch (Dali::DaliException e) {
16187       {
16188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16189       };
16190     } catch (...) {
16191       {
16192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16193       };
16194     }
16195   }
16196
16197   jresult = SWIG_csharp_string_callback(result->c_str());
16198   return jresult;
16199 }
16200
16201
16202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16203   void * jresult ;
16204   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16205   Dali::Property::Map::SizeType arg2 ;
16206   SwigValueWrapper< Dali::Property::Key > result;
16207
16208   arg1 = (Dali::Property::Map *)jarg1;
16209   arg2 = (Dali::Property::Map::SizeType)jarg2;
16210   {
16211     try {
16212       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
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 (Dali::DaliException e) {
16222       {
16223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16224       };
16225     } catch (...) {
16226       {
16227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16228       };
16229     }
16230   }
16231
16232   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16233   return jresult;
16234 }
16235
16236
16237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16238   void * jresult ;
16239   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16240   Dali::Property::Map::SizeType arg2 ;
16241   StringValuePair *result = 0 ;
16242
16243   arg1 = (Dali::Property::Map *)jarg1;
16244   arg2 = (Dali::Property::Map::SizeType)jarg2;
16245   {
16246     try {
16247       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16248     } catch (std::out_of_range& e) {
16249       {
16250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16251       };
16252     } catch (std::exception& e) {
16253       {
16254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16255       };
16256     } catch (Dali::DaliException e) {
16257       {
16258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16259       };
16260     } catch (...) {
16261       {
16262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16263       };
16264     }
16265   }
16266
16267   jresult = (void *)result;
16268   return jresult;
16269 }
16270
16271
16272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16273   void * jresult ;
16274   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16275   char *arg2 = (char *) 0 ;
16276   Dali::Property::Value *result = 0 ;
16277
16278   arg1 = (Dali::Property::Map *)jarg1;
16279   arg2 = (char *)jarg2;
16280   {
16281     try {
16282       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16283     } catch (std::out_of_range& e) {
16284       {
16285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16286       };
16287     } catch (std::exception& e) {
16288       {
16289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16290       };
16291     } catch (Dali::DaliException e) {
16292       {
16293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16294       };
16295     } catch (...) {
16296       {
16297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16298       };
16299     }
16300   }
16301
16302   jresult = (void *)result;
16303   return jresult;
16304 }
16305
16306
16307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16308   void * jresult ;
16309   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16310   Dali::Property::Index arg2 ;
16311   Dali::Property::Value *result = 0 ;
16312
16313   arg1 = (Dali::Property::Map *)jarg1;
16314   arg2 = (Dali::Property::Index)jarg2;
16315   {
16316     try {
16317       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16318     } catch (std::out_of_range& e) {
16319       {
16320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16321       };
16322     } catch (std::exception& e) {
16323       {
16324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16325       };
16326     } catch (Dali::DaliException e) {
16327       {
16328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16329       };
16330     } catch (...) {
16331       {
16332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16333       };
16334     }
16335   }
16336
16337   jresult = (void *)result;
16338   return jresult;
16339 }
16340
16341
16342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16343   void * jresult ;
16344   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16345   Dali::Property::Index arg2 ;
16346   std::string *arg3 = 0 ;
16347   Dali::Property::Value *result = 0 ;
16348
16349   arg1 = (Dali::Property::Map *)jarg1;
16350   arg2 = (Dali::Property::Index)jarg2;
16351   if (!jarg3) {
16352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16353     return 0;
16354   }
16355   std::string arg3_str(jarg3);
16356   arg3 = &arg3_str;
16357   {
16358     try {
16359       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16360     } catch (std::out_of_range& e) {
16361       {
16362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16363       };
16364     } catch (std::exception& e) {
16365       {
16366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16367       };
16368     } catch (Dali::DaliException e) {
16369       {
16370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16371       };
16372     } catch (...) {
16373       {
16374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16375       };
16376     }
16377   }
16378
16379   jresult = (void *)result;
16380
16381   //argout typemap for const std::string&
16382
16383   return jresult;
16384 }
16385
16386
16387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16388   void * jresult ;
16389   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16390   std::string *arg2 = 0 ;
16391   Dali::Property::Type arg3 ;
16392   Dali::Property::Value *result = 0 ;
16393
16394   arg1 = (Dali::Property::Map *)jarg1;
16395   if (!jarg2) {
16396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16397     return 0;
16398   }
16399   std::string arg2_str(jarg2);
16400   arg2 = &arg2_str;
16401   arg3 = (Dali::Property::Type)jarg3;
16402   {
16403     try {
16404       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16405     } catch (std::out_of_range& e) {
16406       {
16407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16408       };
16409     } catch (std::exception& e) {
16410       {
16411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16412       };
16413     } catch (Dali::DaliException e) {
16414       {
16415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16416       };
16417     } catch (...) {
16418       {
16419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16420       };
16421     }
16422   }
16423
16424   jresult = (void *)result;
16425
16426   //argout typemap for const std::string&
16427
16428   return jresult;
16429 }
16430
16431
16432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16433   void * jresult ;
16434   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16435   Dali::Property::Index arg2 ;
16436   Dali::Property::Type arg3 ;
16437   Dali::Property::Value *result = 0 ;
16438
16439   arg1 = (Dali::Property::Map *)jarg1;
16440   arg2 = (Dali::Property::Index)jarg2;
16441   arg3 = (Dali::Property::Type)jarg3;
16442   {
16443     try {
16444       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16445     } catch (std::out_of_range& e) {
16446       {
16447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16448       };
16449     } catch (std::exception& e) {
16450       {
16451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16452       };
16453     } catch (Dali::DaliException e) {
16454       {
16455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16456       };
16457     } catch (...) {
16458       {
16459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16460       };
16461     }
16462   }
16463
16464   jresult = (void *)result;
16465   return jresult;
16466 }
16467
16468
16469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16470   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16471
16472   arg1 = (Dali::Property::Map *)jarg1;
16473   {
16474     try {
16475       (arg1)->Clear();
16476     } catch (std::out_of_range& e) {
16477       {
16478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16479       };
16480     } catch (std::exception& e) {
16481       {
16482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16483       };
16484     } catch (Dali::DaliException e) {
16485       {
16486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16487       };
16488     } catch (...) {
16489       {
16490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16491       };
16492     }
16493   }
16494
16495 }
16496
16497
16498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16499   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16500   Dali::Property::Map *arg2 = 0 ;
16501
16502   arg1 = (Dali::Property::Map *)jarg1;
16503   arg2 = (Dali::Property::Map *)jarg2;
16504   if (!arg2) {
16505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16506     return ;
16507   }
16508   {
16509     try {
16510       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16511     } catch (std::out_of_range& e) {
16512       {
16513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16514       };
16515     } catch (std::exception& e) {
16516       {
16517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16518       };
16519     } catch (Dali::DaliException e) {
16520       {
16521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16522       };
16523     } catch (...) {
16524       {
16525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16526       };
16527     }
16528   }
16529
16530 }
16531
16532
16533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16534   void * jresult ;
16535   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16536   std::string *arg2 = 0 ;
16537   Dali::Property::Value *result = 0 ;
16538
16539   arg1 = (Dali::Property::Map *)jarg1;
16540   if (!jarg2) {
16541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16542     return 0;
16543   }
16544   std::string arg2_str(jarg2);
16545   arg2 = &arg2_str;
16546   {
16547     try {
16548       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16549     } catch (std::out_of_range& e) {
16550       {
16551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16552       };
16553     } catch (std::exception& e) {
16554       {
16555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16556       };
16557     } catch (Dali::DaliException e) {
16558       {
16559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16560       };
16561     } catch (...) {
16562       {
16563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16564       };
16565     }
16566   }
16567
16568   jresult = (void *)result;
16569
16570   //argout typemap for const std::string&
16571
16572   return jresult;
16573 }
16574
16575
16576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16577   void * jresult ;
16578   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16579   Dali::Property::Index arg2 ;
16580   Dali::Property::Value *result = 0 ;
16581
16582   arg1 = (Dali::Property::Map *)jarg1;
16583   arg2 = (Dali::Property::Index)jarg2;
16584   {
16585     try {
16586       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16587     } catch (std::out_of_range& e) {
16588       {
16589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16590       };
16591     } catch (std::exception& e) {
16592       {
16593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16594       };
16595     } catch (Dali::DaliException e) {
16596       {
16597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16598       };
16599     } catch (...) {
16600       {
16601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16602       };
16603     }
16604   }
16605
16606   jresult = (void *)result;
16607   return jresult;
16608 }
16609
16610
16611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16612   void * jresult ;
16613   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16614   Dali::Property::Map *arg2 = 0 ;
16615   Dali::Property::Map *result = 0 ;
16616
16617   arg1 = (Dali::Property::Map *)jarg1;
16618   arg2 = (Dali::Property::Map *)jarg2;
16619   if (!arg2) {
16620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16621     return 0;
16622   }
16623   {
16624     try {
16625       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16626     } catch (std::out_of_range& e) {
16627       {
16628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16629       };
16630     } catch (std::exception& e) {
16631       {
16632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16633       };
16634     } catch (Dali::DaliException e) {
16635       {
16636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16637       };
16638     } catch (...) {
16639       {
16640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16641       };
16642     }
16643   }
16644
16645   jresult = (void *)result;
16646   return jresult;
16647 }
16648
16649
16650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16651
16652   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16653
16654   if (!jarg2) {
16655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16656     return;
16657   }
16658   std::string arg2_str(jarg2);
16659   std::string* arg2 = &arg2_str;
16660
16661   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16662
16663   {
16664     try {
16665       arg1->operator[]((std::string const &)*arg2) = *arg3;
16666     } catch (std::out_of_range& e) {
16667       {
16668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16669       };
16670     } catch (std::exception& e) {
16671       {
16672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16673       };
16674     } catch (Dali::DaliException e) {
16675       {
16676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16677       };
16678     } catch (...) {
16679       {
16680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16681       };
16682     }
16683   }
16684 }
16685
16686
16687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16688
16689   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16690   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16691   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16692
16693   {
16694     try {
16695       arg1->operator[](arg2) = *arg3;
16696     } catch (std::out_of_range& e) {
16697       {
16698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16699       };
16700     } catch (std::exception& e) {
16701       {
16702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16703       };
16704     } catch (Dali::DaliException e) {
16705       {
16706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16707       };
16708     } catch (...) {
16709       {
16710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16711       };
16712     }
16713   }
16714 }
16715
16716
16717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16718   void * jresult ;
16719   Dali::Property::Value *result = 0 ;
16720
16721   {
16722     try {
16723       result = (Dali::Property::Value *)new Dali::Property::Value();
16724     } catch (std::out_of_range& e) {
16725       {
16726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16727       };
16728     } catch (std::exception& e) {
16729       {
16730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16731       };
16732     } catch (Dali::DaliException e) {
16733       {
16734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16735       };
16736     } catch (...) {
16737       {
16738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16739       };
16740     }
16741   }
16742
16743   jresult = (void *)result;
16744   return jresult;
16745 }
16746
16747
16748 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16749   void * jresult ;
16750   bool arg1 ;
16751   Dali::Property::Value *result = 0 ;
16752
16753   arg1 = jarg1 ? true : false;
16754   {
16755     try {
16756       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16757     } catch (std::out_of_range& e) {
16758       {
16759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16760       };
16761     } catch (std::exception& e) {
16762       {
16763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16764       };
16765     } catch (Dali::DaliException e) {
16766       {
16767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16768       };
16769     } catch (...) {
16770       {
16771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16772       };
16773     }
16774   }
16775
16776   jresult = (void *)result;
16777   return jresult;
16778 }
16779
16780
16781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16782   void * jresult ;
16783   int arg1 ;
16784   Dali::Property::Value *result = 0 ;
16785
16786   arg1 = (int)jarg1;
16787   {
16788     try {
16789       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16790     } catch (std::out_of_range& e) {
16791       {
16792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16793       };
16794     } catch (std::exception& e) {
16795       {
16796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16797       };
16798     } catch (Dali::DaliException e) {
16799       {
16800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16801       };
16802     } catch (...) {
16803       {
16804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16805       };
16806     }
16807   }
16808
16809   jresult = (void *)result;
16810   return jresult;
16811 }
16812
16813
16814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16815   void * jresult ;
16816   float arg1 ;
16817   Dali::Property::Value *result = 0 ;
16818
16819   arg1 = (float)jarg1;
16820   {
16821     try {
16822       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16823     } catch (std::out_of_range& e) {
16824       {
16825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16826       };
16827     } catch (std::exception& e) {
16828       {
16829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16830       };
16831     } catch (Dali::DaliException e) {
16832       {
16833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16834       };
16835     } catch (...) {
16836       {
16837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16838       };
16839     }
16840   }
16841
16842   jresult = (void *)result;
16843   return jresult;
16844 }
16845
16846
16847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16848   void * jresult ;
16849   Dali::Vector2 *arg1 = 0 ;
16850   Dali::Property::Value *result = 0 ;
16851
16852   arg1 = (Dali::Vector2 *)jarg1;
16853   if (!arg1) {
16854     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16855     return 0;
16856   }
16857   {
16858     try {
16859       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16860     } catch (std::out_of_range& e) {
16861       {
16862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16863       };
16864     } catch (std::exception& e) {
16865       {
16866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16867       };
16868     } catch (Dali::DaliException e) {
16869       {
16870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16871       };
16872     } catch (...) {
16873       {
16874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16875       };
16876     }
16877   }
16878
16879   jresult = (void *)result;
16880   return jresult;
16881 }
16882
16883
16884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16885   void * jresult ;
16886   Dali::Vector3 *arg1 = 0 ;
16887   Dali::Property::Value *result = 0 ;
16888
16889   arg1 = (Dali::Vector3 *)jarg1;
16890   if (!arg1) {
16891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16892     return 0;
16893   }
16894   {
16895     try {
16896       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16897     } catch (std::out_of_range& e) {
16898       {
16899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16900       };
16901     } catch (std::exception& e) {
16902       {
16903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16904       };
16905     } catch (Dali::DaliException e) {
16906       {
16907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16908       };
16909     } catch (...) {
16910       {
16911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16912       };
16913     }
16914   }
16915
16916   jresult = (void *)result;
16917   return jresult;
16918 }
16919
16920
16921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16922   void * jresult ;
16923   Dali::Vector4 *arg1 = 0 ;
16924   Dali::Property::Value *result = 0 ;
16925
16926   arg1 = (Dali::Vector4 *)jarg1;
16927   if (!arg1) {
16928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16929     return 0;
16930   }
16931   {
16932     try {
16933       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16934     } catch (std::out_of_range& e) {
16935       {
16936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16937       };
16938     } catch (std::exception& e) {
16939       {
16940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16941       };
16942     } catch (Dali::DaliException e) {
16943       {
16944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16945       };
16946     } catch (...) {
16947       {
16948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16949       };
16950     }
16951   }
16952
16953   jresult = (void *)result;
16954   return jresult;
16955 }
16956
16957
16958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16959   void * jresult ;
16960   Dali::Matrix3 *arg1 = 0 ;
16961   Dali::Property::Value *result = 0 ;
16962
16963   arg1 = (Dali::Matrix3 *)jarg1;
16964   if (!arg1) {
16965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16966     return 0;
16967   }
16968   {
16969     try {
16970       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16971     } catch (std::out_of_range& e) {
16972       {
16973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16974       };
16975     } catch (std::exception& e) {
16976       {
16977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16978       };
16979     } catch (Dali::DaliException e) {
16980       {
16981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16982       };
16983     } catch (...) {
16984       {
16985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16986       };
16987     }
16988   }
16989
16990   jresult = (void *)result;
16991   return jresult;
16992 }
16993
16994
16995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16996   void * jresult ;
16997   Dali::Matrix *arg1 = 0 ;
16998   Dali::Property::Value *result = 0 ;
16999
17000   arg1 = (Dali::Matrix *)jarg1;
17001   if (!arg1) {
17002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
17003     return 0;
17004   }
17005   {
17006     try {
17007       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
17008     } catch (std::out_of_range& e) {
17009       {
17010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17011       };
17012     } catch (std::exception& e) {
17013       {
17014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17015       };
17016     } catch (Dali::DaliException e) {
17017       {
17018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17019       };
17020     } catch (...) {
17021       {
17022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17023       };
17024     }
17025   }
17026
17027   jresult = (void *)result;
17028   return jresult;
17029 }
17030
17031
17032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
17033   void * jresult ;
17034   Dali::Rect< int > *arg1 = 0 ;
17035   Dali::Property::Value *result = 0 ;
17036
17037   arg1 = (Dali::Rect< int > *)jarg1;
17038   if (!arg1) {
17039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
17040     return 0;
17041   }
17042   {
17043     try {
17044       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
17045     } catch (std::out_of_range& e) {
17046       {
17047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17048       };
17049     } catch (std::exception& e) {
17050       {
17051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17052       };
17053     } catch (Dali::DaliException e) {
17054       {
17055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17056       };
17057     } catch (...) {
17058       {
17059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17060       };
17061     }
17062   }
17063
17064   jresult = (void *)result;
17065   return jresult;
17066 }
17067
17068
17069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17070   void * jresult ;
17071   Dali::AngleAxis *arg1 = 0 ;
17072   Dali::Property::Value *result = 0 ;
17073
17074   arg1 = (Dali::AngleAxis *)jarg1;
17075   if (!arg1) {
17076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17077     return 0;
17078   }
17079   {
17080     try {
17081       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17082     } catch (std::out_of_range& e) {
17083       {
17084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17085       };
17086     } catch (std::exception& e) {
17087       {
17088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17089       };
17090     } catch (Dali::DaliException e) {
17091       {
17092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17093       };
17094     } catch (...) {
17095       {
17096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17097       };
17098     }
17099   }
17100
17101   jresult = (void *)result;
17102   return jresult;
17103 }
17104
17105
17106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17107   void * jresult ;
17108   Dali::Quaternion *arg1 = 0 ;
17109   Dali::Property::Value *result = 0 ;
17110
17111   arg1 = (Dali::Quaternion *)jarg1;
17112   if (!arg1) {
17113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17114     return 0;
17115   }
17116   {
17117     try {
17118       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17119     } catch (std::out_of_range& e) {
17120       {
17121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17122       };
17123     } catch (std::exception& e) {
17124       {
17125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17126       };
17127     } catch (Dali::DaliException e) {
17128       {
17129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17130       };
17131     } catch (...) {
17132       {
17133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17134       };
17135     }
17136   }
17137
17138   jresult = (void *)result;
17139   return jresult;
17140 }
17141
17142
17143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17144   void * jresult ;
17145   std::string *arg1 = 0 ;
17146   Dali::Property::Value *result = 0 ;
17147
17148   if (!jarg1) {
17149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17150     return 0;
17151   }
17152   std::string arg1_str(jarg1);
17153   arg1 = &arg1_str;
17154   {
17155     try {
17156       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17157     } catch (std::out_of_range& e) {
17158       {
17159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17160       };
17161     } catch (std::exception& e) {
17162       {
17163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17164       };
17165     } catch (Dali::DaliException e) {
17166       {
17167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17168       };
17169     } catch (...) {
17170       {
17171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17172       };
17173     }
17174   }
17175
17176   jresult = (void *)result;
17177
17178   //argout typemap for const std::string&
17179
17180   return jresult;
17181 }
17182
17183
17184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17185   void * jresult ;
17186   Dali::Property::Array *arg1 = 0 ;
17187   Dali::Property::Value *result = 0 ;
17188
17189   arg1 = (Dali::Property::Array *)jarg1;
17190   if (!arg1) {
17191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17192     return 0;
17193   }
17194   {
17195     try {
17196       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17197     } catch (std::out_of_range& e) {
17198       {
17199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17200       };
17201     } catch (std::exception& e) {
17202       {
17203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17204       };
17205     } catch (Dali::DaliException e) {
17206       {
17207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17208       };
17209     } catch (...) {
17210       {
17211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17212       };
17213     }
17214   }
17215
17216   jresult = (void *)result;
17217   return jresult;
17218 }
17219
17220
17221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17222   void * jresult ;
17223   Dali::Property::Map *arg1 = 0 ;
17224   Dali::Property::Value *result = 0 ;
17225
17226   arg1 = (Dali::Property::Map *)jarg1;
17227   if (!arg1) {
17228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17229     return 0;
17230   }
17231   {
17232     try {
17233       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17234     } catch (std::out_of_range& e) {
17235       {
17236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17237       };
17238     } catch (std::exception& e) {
17239       {
17240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17241       };
17242     } catch (Dali::DaliException e) {
17243       {
17244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17245       };
17246     } catch (...) {
17247       {
17248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17249       };
17250     }
17251   }
17252
17253   jresult = (void *)result;
17254   return jresult;
17255 }
17256
17257
17258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17259   void * jresult ;
17260   Extents *arg1 = 0 ;
17261   Dali::Property::Value *result = 0 ;
17262
17263   arg1 = (Extents *)jarg1;
17264   if (!arg1) {
17265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17266     return 0;
17267   }
17268   {
17269     try {
17270       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17271     } catch (std::out_of_range& e) {
17272       {
17273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17274       };
17275     } catch (std::exception& e) {
17276       {
17277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17278       };
17279     } catch (...) {
17280       {
17281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17282       };
17283     }
17284   }
17285   jresult = (void *)result;
17286   return jresult;
17287 }
17288
17289
17290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17291   void * jresult ;
17292   Dali::Property::Type arg1 ;
17293   Dali::Property::Value *result = 0 ;
17294
17295   arg1 = (Dali::Property::Type)jarg1;
17296   {
17297     try {
17298       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17299     } catch (std::out_of_range& e) {
17300       {
17301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17302       };
17303     } catch (std::exception& e) {
17304       {
17305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17306       };
17307     } catch (Dali::DaliException e) {
17308       {
17309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17310       };
17311     } catch (...) {
17312       {
17313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17314       };
17315     }
17316   }
17317
17318   jresult = (void *)result;
17319   return jresult;
17320 }
17321
17322
17323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17324   void * jresult ;
17325   Dali::Property::Value *arg1 = 0 ;
17326   Dali::Property::Value *result = 0 ;
17327
17328   arg1 = (Dali::Property::Value *)jarg1;
17329   if (!arg1) {
17330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17331     return 0;
17332   }
17333   {
17334     try {
17335       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17336     } catch (std::out_of_range& e) {
17337       {
17338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17339       };
17340     } catch (std::exception& e) {
17341       {
17342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17343       };
17344     } catch (Dali::DaliException e) {
17345       {
17346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17347       };
17348     } catch (...) {
17349       {
17350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17351       };
17352     }
17353   }
17354
17355   jresult = (void *)result;
17356   return jresult;
17357 }
17358
17359
17360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17361   void * jresult ;
17362   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17363   Dali::Property::Value *arg2 = 0 ;
17364   Dali::Property::Value *result = 0 ;
17365
17366   arg1 = (Dali::Property::Value *)jarg1;
17367   arg2 = (Dali::Property::Value *)jarg2;
17368   if (!arg2) {
17369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17370     return 0;
17371   }
17372   {
17373     try {
17374       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17375     } catch (std::out_of_range& e) {
17376       {
17377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17378       };
17379     } catch (std::exception& e) {
17380       {
17381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17382       };
17383     } catch (Dali::DaliException e) {
17384       {
17385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17386       };
17387     } catch (...) {
17388       {
17389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17390       };
17391     }
17392   }
17393
17394   jresult = (void *)result;
17395   return jresult;
17396 }
17397
17398
17399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17400   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17401
17402   arg1 = (Dali::Property::Value *)jarg1;
17403   {
17404     try {
17405       delete arg1;
17406     } catch (std::out_of_range& e) {
17407       {
17408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17409       };
17410     } catch (std::exception& e) {
17411       {
17412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17413       };
17414     } catch (Dali::DaliException e) {
17415       {
17416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17417       };
17418     } catch (...) {
17419       {
17420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17421       };
17422     }
17423   }
17424
17425 }
17426
17427
17428 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17429   int jresult ;
17430   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17431   Dali::Property::Type result;
17432
17433   arg1 = (Dali::Property::Value *)jarg1;
17434   {
17435     try {
17436       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17437     } catch (std::out_of_range& e) {
17438       {
17439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17440       };
17441     } catch (std::exception& e) {
17442       {
17443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17444       };
17445     } catch (Dali::DaliException e) {
17446       {
17447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17448       };
17449     } catch (...) {
17450       {
17451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17452       };
17453     }
17454   }
17455
17456   jresult = (int)result;
17457   return jresult;
17458 }
17459
17460
17461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17462   unsigned int jresult ;
17463   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17464   bool *arg2 = 0 ;
17465   bool result;
17466
17467   arg1 = (Dali::Property::Value *)jarg1;
17468   arg2 = (bool *)jarg2;
17469   {
17470     try {
17471       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17472     } catch (std::out_of_range& e) {
17473       {
17474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17475       };
17476     } catch (std::exception& e) {
17477       {
17478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17479       };
17480     } catch (Dali::DaliException e) {
17481       {
17482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17483       };
17484     } catch (...) {
17485       {
17486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17487       };
17488     }
17489   }
17490
17491   jresult = result;
17492   return jresult;
17493 }
17494
17495
17496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17497   unsigned int jresult ;
17498   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17499   float *arg2 = 0 ;
17500   bool result;
17501
17502   arg1 = (Dali::Property::Value *)jarg1;
17503   arg2 = (float *)jarg2;
17504   {
17505     try {
17506       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17507     } catch (std::out_of_range& e) {
17508       {
17509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17510       };
17511     } catch (std::exception& e) {
17512       {
17513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17514       };
17515     } catch (Dali::DaliException e) {
17516       {
17517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17518       };
17519     } catch (...) {
17520       {
17521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17522       };
17523     }
17524   }
17525
17526   jresult = result;
17527   return jresult;
17528 }
17529
17530
17531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17532   unsigned int jresult ;
17533   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17534   int *arg2 = 0 ;
17535   bool result;
17536
17537   arg1 = (Dali::Property::Value *)jarg1;
17538   arg2 = (int *)jarg2;
17539   {
17540     try {
17541       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
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 (Dali::DaliException e) {
17551       {
17552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17553       };
17554     } catch (...) {
17555       {
17556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17557       };
17558     }
17559   }
17560
17561   jresult = result;
17562   return jresult;
17563 }
17564
17565
17566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17567   unsigned int jresult ;
17568   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17569   Dali::Rect< int > *arg2 = 0 ;
17570   bool result;
17571
17572   arg1 = (Dali::Property::Value *)jarg1;
17573   arg2 = (Dali::Rect< int > *)jarg2;
17574   if (!arg2) {
17575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17576     return 0;
17577   }
17578   {
17579     try {
17580       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17581     } catch (std::out_of_range& e) {
17582       {
17583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17584       };
17585     } catch (std::exception& e) {
17586       {
17587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17588       };
17589     } catch (Dali::DaliException e) {
17590       {
17591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17592       };
17593     } catch (...) {
17594       {
17595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17596       };
17597     }
17598   }
17599
17600   jresult = result;
17601   return jresult;
17602 }
17603
17604
17605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17606   unsigned int jresult ;
17607   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17608   Dali::Vector2 *arg2 = 0 ;
17609   bool result;
17610
17611   arg1 = (Dali::Property::Value *)jarg1;
17612   arg2 = (Dali::Vector2 *)jarg2;
17613   if (!arg2) {
17614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17615     return 0;
17616   }
17617   {
17618     try {
17619       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17620     } catch (std::out_of_range& e) {
17621       {
17622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17623       };
17624     } catch (std::exception& e) {
17625       {
17626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17627       };
17628     } catch (Dali::DaliException e) {
17629       {
17630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17631       };
17632     } catch (...) {
17633       {
17634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17635       };
17636     }
17637   }
17638
17639   jresult = result;
17640   return jresult;
17641 }
17642
17643
17644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17645   unsigned int jresult ;
17646   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17647   Dali::Vector3 *arg2 = 0 ;
17648   bool result;
17649
17650   arg1 = (Dali::Property::Value *)jarg1;
17651   arg2 = (Dali::Vector3 *)jarg2;
17652   if (!arg2) {
17653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17654     return 0;
17655   }
17656   {
17657     try {
17658       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17659     } catch (std::out_of_range& e) {
17660       {
17661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17662       };
17663     } catch (std::exception& e) {
17664       {
17665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17666       };
17667     } catch (Dali::DaliException e) {
17668       {
17669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17670       };
17671     } catch (...) {
17672       {
17673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17674       };
17675     }
17676   }
17677
17678   jresult = result;
17679   return jresult;
17680 }
17681
17682
17683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17684   unsigned int jresult ;
17685   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17686   Dali::Vector4 *arg2 = 0 ;
17687   bool result;
17688
17689   arg1 = (Dali::Property::Value *)jarg1;
17690   arg2 = (Dali::Vector4 *)jarg2;
17691   if (!arg2) {
17692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17693     return 0;
17694   }
17695   {
17696     try {
17697       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17698     } catch (std::out_of_range& e) {
17699       {
17700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17701       };
17702     } catch (std::exception& e) {
17703       {
17704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17705       };
17706     } catch (Dali::DaliException e) {
17707       {
17708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17709       };
17710     } catch (...) {
17711       {
17712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17713       };
17714     }
17715   }
17716
17717   jresult = result;
17718   return jresult;
17719 }
17720
17721
17722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17723   unsigned int jresult ;
17724   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17725   Dali::Matrix3 *arg2 = 0 ;
17726   bool result;
17727
17728   arg1 = (Dali::Property::Value *)jarg1;
17729   arg2 = (Dali::Matrix3 *)jarg2;
17730   if (!arg2) {
17731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17732     return 0;
17733   }
17734   {
17735     try {
17736       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17737     } catch (std::out_of_range& e) {
17738       {
17739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17740       };
17741     } catch (std::exception& e) {
17742       {
17743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17744       };
17745     } catch (Dali::DaliException e) {
17746       {
17747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17748       };
17749     } catch (...) {
17750       {
17751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17752       };
17753     }
17754   }
17755
17756   jresult = result;
17757   return jresult;
17758 }
17759
17760
17761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17762   unsigned int jresult ;
17763   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17764   Dali::Matrix *arg2 = 0 ;
17765   bool result;
17766
17767   arg1 = (Dali::Property::Value *)jarg1;
17768   arg2 = (Dali::Matrix *)jarg2;
17769   if (!arg2) {
17770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17771     return 0;
17772   }
17773   {
17774     try {
17775       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17776     } catch (std::out_of_range& e) {
17777       {
17778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17779       };
17780     } catch (std::exception& e) {
17781       {
17782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17783       };
17784     } catch (Dali::DaliException e) {
17785       {
17786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17787       };
17788     } catch (...) {
17789       {
17790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17791       };
17792     }
17793   }
17794
17795   jresult = result;
17796   return jresult;
17797 }
17798
17799
17800 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17801   unsigned int jresult ;
17802   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17803   Dali::AngleAxis *arg2 = 0 ;
17804   bool result;
17805
17806   arg1 = (Dali::Property::Value *)jarg1;
17807   arg2 = (Dali::AngleAxis *)jarg2;
17808   if (!arg2) {
17809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17810     return 0;
17811   }
17812   {
17813     try {
17814       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17815     } catch (std::out_of_range& e) {
17816       {
17817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17818       };
17819     } catch (std::exception& e) {
17820       {
17821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17822       };
17823     } catch (Dali::DaliException e) {
17824       {
17825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17826       };
17827     } catch (...) {
17828       {
17829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17830       };
17831     }
17832   }
17833
17834   jresult = result;
17835   return jresult;
17836 }
17837
17838
17839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17840   unsigned int jresult ;
17841   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17842   Dali::Quaternion *arg2 = 0 ;
17843   bool result;
17844
17845   arg1 = (Dali::Property::Value *)jarg1;
17846   arg2 = (Dali::Quaternion *)jarg2;
17847   if (!arg2) {
17848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17849     return 0;
17850   }
17851   {
17852     try {
17853       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17854     } catch (std::out_of_range& e) {
17855       {
17856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17857       };
17858     } catch (std::exception& e) {
17859       {
17860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17861       };
17862     } catch (Dali::DaliException e) {
17863       {
17864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17865       };
17866     } catch (...) {
17867       {
17868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17869       };
17870     }
17871   }
17872
17873   jresult = result;
17874   return jresult;
17875 }
17876
17877
17878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17879   unsigned int jresult ;
17880   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17881   std::string *arg2 = 0 ;
17882   bool result;
17883
17884   arg1 = (Dali::Property::Value *)jarg1;
17885
17886   //typemap in
17887   std::string temp;
17888   arg2 = &temp;
17889
17890   {
17891     try {
17892       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17893     } catch (std::out_of_range& e) {
17894       {
17895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17896       };
17897     } catch (std::exception& e) {
17898       {
17899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17900       };
17901     } catch (Dali::DaliException e) {
17902       {
17903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17904       };
17905     } catch (...) {
17906       {
17907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17908       };
17909     }
17910   }
17911
17912   jresult = result;
17913
17914   //Typemap argout in c++ file.
17915   //This will convert c++ string to c# string
17916   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17917
17918   return jresult;
17919 }
17920
17921
17922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17923   unsigned int jresult ;
17924   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17925   Dali::Property::Array *arg2 = 0 ;
17926   bool result;
17927
17928   arg1 = (Dali::Property::Value *)jarg1;
17929   arg2 = (Dali::Property::Array *)jarg2;
17930   if (!arg2) {
17931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17932     return 0;
17933   }
17934   {
17935     try {
17936       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17937     } catch (std::out_of_range& e) {
17938       {
17939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17940       };
17941     } catch (std::exception& e) {
17942       {
17943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17944       };
17945     } catch (Dali::DaliException e) {
17946       {
17947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17948       };
17949     } catch (...) {
17950       {
17951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17952       };
17953     }
17954   }
17955
17956   jresult = result;
17957   return jresult;
17958 }
17959
17960
17961 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17962   unsigned int jresult ;
17963   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17964   Dali::Property::Map *arg2 = 0 ;
17965   bool result;
17966
17967   arg1 = (Dali::Property::Value *)jarg1;
17968   arg2 = (Dali::Property::Map *)jarg2;
17969   if (!arg2) {
17970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17971     return 0;
17972   }
17973   {
17974     try {
17975       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17976     } catch (std::out_of_range& e) {
17977       {
17978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17979       };
17980     } catch (std::exception& e) {
17981       {
17982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17983       };
17984     } catch (Dali::DaliException e) {
17985       {
17986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17987       };
17988     } catch (...) {
17989       {
17990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17991       };
17992     }
17993   }
17994
17995   jresult = result;
17996   return jresult;
17997 }
17998
17999
18000 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
18001   unsigned int jresult ;
18002   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18003   Extents *arg2 = 0 ;
18004   bool result;
18005
18006   arg1 = (Dali::Property::Value *)jarg1;
18007   arg2 = (Extents *)jarg2;
18008   if (!arg2) {
18009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
18010     return 0;
18011   }
18012   {
18013     try {
18014       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
18015     } catch (std::out_of_range& e) {
18016       {
18017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18018       };
18019     } catch (std::exception& e) {
18020       {
18021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18022       };
18023     } catch (...) {
18024       {
18025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18026       };
18027     }
18028   }
18029   jresult = result;
18030   return jresult;
18031 }
18032
18033
18034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
18035   void * jresult ;
18036   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18037   Dali::Property::Array *result = 0 ;
18038
18039   arg1 = (Dali::Property::Value *)jarg1;
18040   {
18041     try {
18042       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
18043     } catch (std::out_of_range& e) {
18044       {
18045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18046       };
18047     } catch (std::exception& e) {
18048       {
18049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18050       };
18051     } catch (Dali::DaliException e) {
18052       {
18053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18054       };
18055     } catch (...) {
18056       {
18057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18058       };
18059     }
18060   }
18061
18062   jresult = (void *)result;
18063   return jresult;
18064 }
18065
18066
18067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18068   void * jresult ;
18069   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18070   Dali::Property::Map *result = 0 ;
18071
18072   arg1 = (Dali::Property::Value *)jarg1;
18073   {
18074     try {
18075       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18076     } catch (std::out_of_range& e) {
18077       {
18078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18079       };
18080     } catch (std::exception& e) {
18081       {
18082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18083       };
18084     } catch (Dali::DaliException e) {
18085       {
18086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18087       };
18088     } catch (...) {
18089       {
18090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18091       };
18092     }
18093   }
18094
18095   jresult = (void *)result;
18096   return jresult;
18097 }
18098
18099
18100 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18101   char * jresult ;
18102   Dali::Property::Type arg1 ;
18103   char *result = 0 ;
18104
18105   arg1 = (Dali::Property::Type)jarg1;
18106   {
18107     try {
18108       result = (char *)Dali::PropertyTypes::GetName(arg1);
18109     } catch (std::out_of_range& e) {
18110       {
18111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18112       };
18113     } catch (std::exception& e) {
18114       {
18115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18116       };
18117     } catch (Dali::DaliException e) {
18118       {
18119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18120       };
18121     } catch (...) {
18122       {
18123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18124       };
18125     }
18126   }
18127
18128   jresult = SWIG_csharp_string_callback((const char *)result);
18129   return jresult;
18130 }
18131
18132
18133 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18134   unsigned int jresult ;
18135   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18136   std::string *arg2 = 0 ;
18137   Dali::Property::Map *arg3 = 0 ;
18138   bool result;
18139
18140   arg1 = (Dali::BaseObject *)jarg1;
18141   if (!jarg2) {
18142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18143     return 0;
18144   }
18145   std::string arg2_str(jarg2);
18146   arg2 = &arg2_str;
18147   arg3 = (Dali::Property::Map *)jarg3;
18148   if (!arg3) {
18149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18150     return 0;
18151   }
18152   {
18153     try {
18154       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18155     } catch (std::out_of_range& e) {
18156       {
18157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18158       };
18159     } catch (std::exception& e) {
18160       {
18161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18162       };
18163     } catch (Dali::DaliException e) {
18164       {
18165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18166       };
18167     } catch (...) {
18168       {
18169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18170       };
18171     }
18172   }
18173
18174   jresult = result;
18175
18176   //argout typemap for const std::string&
18177
18178   return jresult;
18179 }
18180
18181
18182 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18183   char * jresult ;
18184   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18185   std::string *result = 0 ;
18186
18187   arg1 = (Dali::BaseObject *)jarg1;
18188   {
18189     try {
18190       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18191     } catch (std::out_of_range& e) {
18192       {
18193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18194       };
18195     } catch (std::exception& e) {
18196       {
18197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18198       };
18199     } catch (Dali::DaliException e) {
18200       {
18201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18202       };
18203     } catch (...) {
18204       {
18205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18206       };
18207     }
18208   }
18209
18210   jresult = SWIG_csharp_string_callback(result->c_str());
18211   return jresult;
18212 }
18213
18214
18215 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18216   unsigned int jresult ;
18217   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18218   Dali::TypeInfo *arg2 = 0 ;
18219   bool result;
18220
18221   arg1 = (Dali::BaseObject *)jarg1;
18222   arg2 = (Dali::TypeInfo *)jarg2;
18223   if (!arg2) {
18224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18225     return 0;
18226   }
18227   {
18228     try {
18229       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18230     } catch (std::out_of_range& e) {
18231       {
18232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18233       };
18234     } catch (std::exception& e) {
18235       {
18236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18237       };
18238     } catch (Dali::DaliException e) {
18239       {
18240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18241       };
18242     } catch (...) {
18243       {
18244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18245       };
18246     }
18247   }
18248
18249   jresult = result;
18250   return jresult;
18251 }
18252
18253
18254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18255   unsigned int jresult ;
18256   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18257   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18258   std::string *arg3 = 0 ;
18259   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18260   bool result;
18261
18262   arg1 = (Dali::BaseObject *)jarg1;
18263   arg2 = (ConnectionTrackerInterface *)jarg2;
18264   if (!jarg3) {
18265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18266     return 0;
18267   }
18268   std::string arg3_str(jarg3);
18269   arg3 = &arg3_str;
18270   arg4 = (FunctorDelegate *)jarg4;
18271   {
18272     try {
18273       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18274     } catch (std::out_of_range& e) {
18275       {
18276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18277       };
18278     } catch (std::exception& e) {
18279       {
18280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18281       };
18282     } catch (Dali::DaliException e) {
18283       {
18284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18285       };
18286     } catch (...) {
18287       {
18288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18289       };
18290     }
18291   }
18292
18293   jresult = result;
18294
18295   //argout typemap for const std::string&
18296
18297   return jresult;
18298 }
18299
18300
18301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18302   void * jresult ;
18303   Dali::BaseHandle *arg1 = 0 ;
18304   Dali::BaseObject *result = 0 ;
18305
18306   arg1 = (Dali::BaseHandle *)jarg1;
18307   if (!arg1) {
18308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18309     return 0;
18310   }
18311   {
18312     try {
18313       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18314     } catch (std::out_of_range& e) {
18315       {
18316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18317       };
18318     } catch (std::exception& e) {
18319       {
18320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18321       };
18322     } catch (Dali::DaliException e) {
18323       {
18324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18325       };
18326     } catch (...) {
18327       {
18328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18329       };
18330     }
18331   }
18332
18333   jresult = (void *)result;
18334   return jresult;
18335 }
18336
18337
18338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18339   void * jresult ;
18340   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18341   Dali::BaseHandle *result = 0 ;
18342
18343   arg1 = (Dali::BaseObject *)jarg1;
18344   {
18345     try {
18346       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18347     } catch (std::out_of_range& e) {
18348       {
18349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18350       };
18351     } catch (std::exception& e) {
18352       {
18353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18354       };
18355     } catch (Dali::DaliException e) {
18356       {
18357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18358       };
18359     } catch (...) {
18360       {
18361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18362       };
18363     }
18364   }
18365
18366   jresult = (void *)result;
18367   return jresult;
18368 }
18369
18370
18371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18372   void * jresult ;
18373   Dali::BaseHandle *result = 0 ;
18374
18375   {
18376     try {
18377       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18378     } catch (std::out_of_range& e) {
18379       {
18380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18381       };
18382     } catch (std::exception& e) {
18383       {
18384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18385       };
18386     } catch (Dali::DaliException e) {
18387       {
18388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18389       };
18390     } catch (...) {
18391       {
18392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18393       };
18394     }
18395   }
18396
18397   jresult = (void *)result;
18398   return jresult;
18399 }
18400
18401
18402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18403   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18404
18405   arg1 = (Dali::BaseHandle *)jarg1;
18406   {
18407     try {
18408       delete arg1;
18409     } catch (std::out_of_range& e) {
18410       {
18411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18412       };
18413     } catch (std::exception& e) {
18414       {
18415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18416       };
18417     } catch (Dali::DaliException e) {
18418       {
18419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18420       };
18421     } catch (...) {
18422       {
18423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18424       };
18425     }
18426   }
18427
18428 }
18429
18430
18431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18432   void * jresult ;
18433   Dali::BaseHandle *arg1 = 0 ;
18434   Dali::BaseHandle *result = 0 ;
18435
18436   arg1 = (Dali::BaseHandle *)jarg1;
18437   if (!arg1) {
18438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18439     return 0;
18440   }
18441   {
18442     try {
18443       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18444     } catch (std::out_of_range& e) {
18445       {
18446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18447       };
18448     } catch (std::exception& e) {
18449       {
18450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18451       };
18452     } catch (Dali::DaliException e) {
18453       {
18454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18455       };
18456     } catch (...) {
18457       {
18458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18459       };
18460     }
18461   }
18462
18463   jresult = (void *)result;
18464   return jresult;
18465 }
18466
18467
18468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18469   void * jresult ;
18470   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18471   Dali::BaseHandle *arg2 = 0 ;
18472   Dali::BaseHandle *result = 0 ;
18473
18474   arg1 = (Dali::BaseHandle *)jarg1;
18475   arg2 = (Dali::BaseHandle *)jarg2;
18476   if (!arg2) {
18477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18478     return 0;
18479   }
18480   {
18481     try {
18482       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18483     } catch (std::out_of_range& e) {
18484       {
18485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18486       };
18487     } catch (std::exception& e) {
18488       {
18489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18490       };
18491     } catch (Dali::DaliException e) {
18492       {
18493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18494       };
18495     } catch (...) {
18496       {
18497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18498       };
18499     }
18500   }
18501
18502   jresult = (void *)result;
18503   return jresult;
18504 }
18505
18506
18507 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18508   unsigned int jresult ;
18509   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18510   std::string *arg2 = 0 ;
18511   Dali::Property::Map *arg3 = 0 ;
18512   bool result;
18513
18514   arg1 = (Dali::BaseHandle *)jarg1;
18515   if (!jarg2) {
18516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18517     return 0;
18518   }
18519   std::string arg2_str(jarg2);
18520   arg2 = &arg2_str;
18521   arg3 = (Dali::Property::Map *)jarg3;
18522   if (!arg3) {
18523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18524     return 0;
18525   }
18526   {
18527     try {
18528       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18529     } catch (std::out_of_range& e) {
18530       {
18531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18532       };
18533     } catch (std::exception& e) {
18534       {
18535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18536       };
18537     } catch (Dali::DaliException e) {
18538       {
18539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18540       };
18541     } catch (...) {
18542       {
18543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18544       };
18545     }
18546   }
18547
18548   jresult = result;
18549
18550   //argout typemap for const std::string&
18551
18552   return jresult;
18553 }
18554
18555
18556 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18557   char * jresult ;
18558   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18559   std::string *result = 0 ;
18560
18561   arg1 = (Dali::BaseHandle *)jarg1;
18562   {
18563     try {
18564       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18565     } catch (std::out_of_range& e) {
18566       {
18567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18568       };
18569     } catch (std::exception& e) {
18570       {
18571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18572       };
18573     } catch (Dali::DaliException e) {
18574       {
18575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18576       };
18577     } catch (...) {
18578       {
18579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18580       };
18581     }
18582   }
18583
18584   jresult = SWIG_csharp_string_callback(result->c_str());
18585   return jresult;
18586 }
18587
18588
18589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18590   unsigned int jresult ;
18591   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18592   Dali::TypeInfo *arg2 = 0 ;
18593   bool result;
18594
18595   arg1 = (Dali::BaseHandle *)jarg1;
18596   arg2 = (Dali::TypeInfo *)jarg2;
18597   if (!arg2) {
18598     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18599     return 0;
18600   }
18601   {
18602     try {
18603       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18604     } catch (std::out_of_range& e) {
18605       {
18606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18607       };
18608     } catch (std::exception& e) {
18609       {
18610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18611       };
18612     } catch (Dali::DaliException e) {
18613       {
18614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18615       };
18616     } catch (...) {
18617       {
18618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18619       };
18620     }
18621   }
18622
18623   jresult = result;
18624   return jresult;
18625 }
18626
18627
18628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18629   void * jresult ;
18630   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18631   Dali::BaseObject *result = 0 ;
18632
18633   arg1 = (Dali::BaseHandle *)jarg1;
18634   {
18635     try {
18636       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18637     } catch (std::out_of_range& e) {
18638       {
18639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18640       };
18641     } catch (std::exception& e) {
18642       {
18643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18644       };
18645     } catch (Dali::DaliException e) {
18646       {
18647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18648       };
18649     } catch (...) {
18650       {
18651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18652       };
18653     }
18654   }
18655
18656   jresult = (void *)result;
18657   return jresult;
18658 }
18659
18660
18661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18662   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18663
18664   arg1 = (Dali::BaseHandle *)jarg1;
18665   {
18666     try {
18667       (arg1)->Reset();
18668     } catch (std::out_of_range& e) {
18669       {
18670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18671       };
18672     } catch (std::exception& e) {
18673       {
18674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18675       };
18676     } catch (Dali::DaliException e) {
18677       {
18678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18679       };
18680     } catch (...) {
18681       {
18682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18683       };
18684     }
18685   }
18686
18687 }
18688
18689
18690 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18691   unsigned int jresult ;
18692   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18693   Dali::BaseHandle *arg2 = 0 ;
18694   bool result;
18695
18696   arg1 = (Dali::BaseHandle *)jarg1;
18697   arg2 = (Dali::BaseHandle *)jarg2;
18698   if (!arg2) {
18699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18700     return 0;
18701   }
18702   {
18703     try {
18704       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18705     } catch (std::out_of_range& e) {
18706       {
18707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18708       };
18709     } catch (std::exception& e) {
18710       {
18711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18712       };
18713     } catch (Dali::DaliException e) {
18714       {
18715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18716       };
18717     } catch (...) {
18718       {
18719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18720       };
18721     }
18722   }
18723
18724   jresult = result;
18725   return jresult;
18726 }
18727
18728
18729 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18730   unsigned int jresult ;
18731   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18732   Dali::BaseHandle *arg2 = 0 ;
18733   bool result;
18734
18735   arg1 = (Dali::BaseHandle *)jarg1;
18736   arg2 = (Dali::BaseHandle *)jarg2;
18737   if (!arg2) {
18738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18739     return 0;
18740   }
18741   {
18742     try {
18743       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18744     } catch (std::out_of_range& e) {
18745       {
18746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18747       };
18748     } catch (std::exception& e) {
18749       {
18750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18751       };
18752     } catch (Dali::DaliException e) {
18753       {
18754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18755       };
18756     } catch (...) {
18757       {
18758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18759       };
18760     }
18761   }
18762
18763   jresult = result;
18764   return jresult;
18765 }
18766
18767
18768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18769   void * jresult ;
18770   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18771   Dali::RefObject *result = 0 ;
18772
18773   arg1 = (Dali::BaseHandle *)jarg1;
18774   {
18775     try {
18776       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18777     } catch (std::out_of_range& e) {
18778       {
18779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18780       };
18781     } catch (std::exception& e) {
18782       {
18783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18784       };
18785     } catch (Dali::DaliException e) {
18786       {
18787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18788       };
18789     } catch (...) {
18790       {
18791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18792       };
18793     }
18794   }
18795
18796   jresult = (void *)result;
18797   return jresult;
18798 }
18799
18800
18801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18802   unsigned int jresult ;
18803   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18804   bool result;
18805
18806   arg1 = (Dali::BaseHandle *)jarg1;
18807   {
18808     try {
18809       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18810     } catch (std::out_of_range& e) {
18811       {
18812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18813       };
18814     } catch (std::exception& e) {
18815       {
18816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18817       };
18818     } catch (Dali::DaliException e) {
18819       {
18820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18821       };
18822     } catch (...) {
18823       {
18824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18825       };
18826     }
18827   }
18828
18829   jresult = result;
18830   return jresult;
18831 }
18832
18833
18834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18835   unsigned int jresult ;
18836   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18837   Dali::BaseHandle *arg2 = 0 ;
18838   bool result;
18839
18840   arg1 = (Dali::BaseHandle *)jarg1;
18841   arg2 = (Dali::BaseHandle *)jarg2;
18842   if (!arg2) {
18843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18844     return 0;
18845   }
18846   {
18847     try {
18848       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18849     } catch (std::out_of_range& e) {
18850       {
18851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18852       };
18853     } catch (std::exception& e) {
18854       {
18855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18856       };
18857     } catch (Dali::DaliException e) {
18858       {
18859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18860       };
18861     } catch (...) {
18862       {
18863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18864       };
18865     }
18866   }
18867
18868   jresult = result;
18869   return jresult;
18870 }
18871
18872
18873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18874   unsigned int jresult ;
18875   Dali::BaseHandle *arg1 = 0 ;
18876   Dali::BaseHandle *arg2 = 0 ;
18877   bool result;
18878
18879   arg1 = (Dali::BaseHandle *)jarg1;
18880   if (!arg1) {
18881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18882     return 0;
18883   }
18884   arg2 = (Dali::BaseHandle *)jarg2;
18885   if (!arg2) {
18886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18887     return 0;
18888   }
18889   {
18890     try {
18891       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18892     } catch (std::out_of_range& e) {
18893       {
18894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18895       };
18896     } catch (std::exception& e) {
18897       {
18898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18899       };
18900     } catch (Dali::DaliException e) {
18901       {
18902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18903       };
18904     } catch (...) {
18905       {
18906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18907       };
18908     }
18909   }
18910
18911   jresult = result;
18912   return jresult;
18913 }
18914
18915
18916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18917   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18918
18919   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18920   {
18921     try {
18922       delete arg1;
18923     } catch (std::out_of_range& e) {
18924       {
18925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18926       };
18927     } catch (std::exception& e) {
18928       {
18929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18930       };
18931     } catch (Dali::DaliException e) {
18932       {
18933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18934       };
18935     } catch (...) {
18936       {
18937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18938       };
18939     }
18940   }
18941
18942 }
18943
18944
18945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18946   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18947   SlotObserver *arg2 = (SlotObserver *) 0 ;
18948   CallbackBase *arg3 = (CallbackBase *) 0 ;
18949
18950   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18951   arg2 = (SlotObserver *)jarg2;
18952   arg3 = (CallbackBase *)jarg3;
18953   {
18954     try {
18955       (arg1)->SignalConnected(arg2,arg3);
18956     } catch (std::out_of_range& e) {
18957       {
18958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18959       };
18960     } catch (std::exception& e) {
18961       {
18962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18963       };
18964     } catch (Dali::DaliException e) {
18965       {
18966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18967       };
18968     } catch (...) {
18969       {
18970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18971       };
18972     }
18973   }
18974
18975 }
18976
18977
18978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18979   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18980
18981   arg1 = (Dali::SignalObserver *)jarg1;
18982   {
18983     try {
18984       delete arg1;
18985     } catch (std::out_of_range& e) {
18986       {
18987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18988       };
18989     } catch (std::exception& e) {
18990       {
18991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18992       };
18993     } catch (Dali::DaliException e) {
18994       {
18995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18996       };
18997     } catch (...) {
18998       {
18999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19000       };
19001     }
19002   }
19003
19004 }
19005
19006
19007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19008   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
19009   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19010   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19011
19012   arg1 = (Dali::SignalObserver *)jarg1;
19013   arg2 = (Dali::SlotObserver *)jarg2;
19014   arg3 = (Dali::CallbackBase *)jarg3;
19015   {
19016     try {
19017       (arg1)->SignalDisconnected(arg2,arg3);
19018     } catch (std::out_of_range& e) {
19019       {
19020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19021       };
19022     } catch (std::exception& e) {
19023       {
19024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19025       };
19026     } catch (Dali::DaliException e) {
19027       {
19028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19029       };
19030     } catch (...) {
19031       {
19032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19033       };
19034     }
19035   }
19036
19037 }
19038
19039
19040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
19041   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19042
19043   arg1 = (Dali::SlotObserver *)jarg1;
19044   {
19045     try {
19046       delete arg1;
19047     } catch (std::out_of_range& e) {
19048       {
19049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19050       };
19051     } catch (std::exception& e) {
19052       {
19053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19054       };
19055     } catch (Dali::DaliException e) {
19056       {
19057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19058       };
19059     } catch (...) {
19060       {
19061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19062       };
19063     }
19064   }
19065
19066 }
19067
19068
19069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19070   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19071   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19072
19073   arg1 = (Dali::SlotObserver *)jarg1;
19074   arg2 = (Dali::CallbackBase *)jarg2;
19075   {
19076     try {
19077       (arg1)->SlotDisconnected(arg2);
19078     } catch (std::out_of_range& e) {
19079       {
19080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19081       };
19082     } catch (std::exception& e) {
19083       {
19084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19085       };
19086     } catch (Dali::DaliException e) {
19087       {
19088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19089       };
19090     } catch (...) {
19091       {
19092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19093       };
19094     }
19095   }
19096
19097 }
19098
19099
19100 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19101   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19102
19103   arg1 = (Dali::ConnectionTracker *)jarg1;
19104   {
19105     try {
19106       delete arg1;
19107     } catch (std::out_of_range& e) {
19108       {
19109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19110       };
19111     } catch (std::exception& e) {
19112       {
19113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19114       };
19115     } catch (Dali::DaliException e) {
19116       {
19117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19118       };
19119     } catch (...) {
19120       {
19121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19122       };
19123     }
19124   }
19125
19126 }
19127
19128
19129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19130   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19131
19132   arg1 = (Dali::ConnectionTracker *)jarg1;
19133   {
19134     try {
19135       (arg1)->DisconnectAll();
19136     } catch (std::out_of_range& e) {
19137       {
19138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19139       };
19140     } catch (std::exception& e) {
19141       {
19142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19143       };
19144     } catch (Dali::DaliException e) {
19145       {
19146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19147       };
19148     } catch (...) {
19149       {
19150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19151       };
19152     }
19153   }
19154
19155 }
19156
19157
19158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19159   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19160   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19161   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19162
19163   arg1 = (Dali::ConnectionTracker *)jarg1;
19164   arg2 = (Dali::SlotObserver *)jarg2;
19165   arg3 = (Dali::CallbackBase *)jarg3;
19166   {
19167     try {
19168       (arg1)->SignalConnected(arg2,arg3);
19169     } catch (std::out_of_range& e) {
19170       {
19171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19172       };
19173     } catch (std::exception& e) {
19174       {
19175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19176       };
19177     } catch (Dali::DaliException e) {
19178       {
19179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19180       };
19181     } catch (...) {
19182       {
19183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19184       };
19185     }
19186   }
19187
19188 }
19189
19190
19191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19192   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19193   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19194   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19195
19196   arg1 = (Dali::ConnectionTracker *)jarg1;
19197   arg2 = (Dali::SlotObserver *)jarg2;
19198   arg3 = (Dali::CallbackBase *)jarg3;
19199   {
19200     try {
19201       (arg1)->SignalDisconnected(arg2,arg3);
19202     } catch (std::out_of_range& e) {
19203       {
19204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19205       };
19206     } catch (std::exception& e) {
19207       {
19208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19209       };
19210     } catch (Dali::DaliException e) {
19211       {
19212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19213       };
19214     } catch (...) {
19215       {
19216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19217       };
19218     }
19219   }
19220
19221 }
19222
19223
19224 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19225   unsigned long jresult ;
19226   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19227   std::size_t result;
19228
19229   arg1 = (Dali::ConnectionTracker *)jarg1;
19230   {
19231     try {
19232       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19233     } catch (std::out_of_range& e) {
19234       {
19235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19236       };
19237     } catch (std::exception& e) {
19238       {
19239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19240       };
19241     } catch (Dali::DaliException e) {
19242       {
19243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19244       };
19245     } catch (...) {
19246       {
19247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19248       };
19249     }
19250   }
19251
19252   jresult = (unsigned long)result;
19253   return jresult;
19254 }
19255
19256
19257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19258   void * jresult ;
19259   Dali::ObjectRegistry *result = 0 ;
19260
19261   {
19262     try {
19263       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19264     } catch (std::out_of_range& e) {
19265       {
19266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19267       };
19268     } catch (std::exception& e) {
19269       {
19270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19271       };
19272     } catch (Dali::DaliException e) {
19273       {
19274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19275       };
19276     } catch (...) {
19277       {
19278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19279       };
19280     }
19281   }
19282
19283   jresult = (void *)result;
19284   return jresult;
19285 }
19286
19287
19288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19289   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19290
19291   arg1 = (Dali::ObjectRegistry *)jarg1;
19292   {
19293     try {
19294       delete arg1;
19295     } catch (std::out_of_range& e) {
19296       {
19297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19298       };
19299     } catch (std::exception& e) {
19300       {
19301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19302       };
19303     } catch (Dali::DaliException e) {
19304       {
19305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19306       };
19307     } catch (...) {
19308       {
19309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19310       };
19311     }
19312   }
19313
19314 }
19315
19316
19317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19318   void * jresult ;
19319   Dali::ObjectRegistry *arg1 = 0 ;
19320   Dali::ObjectRegistry *result = 0 ;
19321
19322   arg1 = (Dali::ObjectRegistry *)jarg1;
19323   if (!arg1) {
19324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19325     return 0;
19326   }
19327   {
19328     try {
19329       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19330     } catch (std::out_of_range& e) {
19331       {
19332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19333       };
19334     } catch (std::exception& e) {
19335       {
19336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19337       };
19338     } catch (Dali::DaliException e) {
19339       {
19340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19341       };
19342     } catch (...) {
19343       {
19344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19345       };
19346     }
19347   }
19348
19349   jresult = (void *)result;
19350   return jresult;
19351 }
19352
19353
19354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19355   void * jresult ;
19356   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19357   Dali::ObjectRegistry *arg2 = 0 ;
19358   Dali::ObjectRegistry *result = 0 ;
19359
19360   arg1 = (Dali::ObjectRegistry *)jarg1;
19361   arg2 = (Dali::ObjectRegistry *)jarg2;
19362   if (!arg2) {
19363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19364     return 0;
19365   }
19366   {
19367     try {
19368       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19369     } catch (std::out_of_range& e) {
19370       {
19371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19372       };
19373     } catch (std::exception& e) {
19374       {
19375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19376       };
19377     } catch (Dali::DaliException e) {
19378       {
19379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19380       };
19381     } catch (...) {
19382       {
19383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19384       };
19385     }
19386   }
19387
19388   jresult = (void *)result;
19389   return jresult;
19390 }
19391
19392
19393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19394   void * jresult ;
19395   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19396   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19397
19398   arg1 = (Dali::ObjectRegistry *)jarg1;
19399   {
19400     try {
19401       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19402     } catch (std::out_of_range& e) {
19403       {
19404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19405       };
19406     } catch (std::exception& e) {
19407       {
19408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19409       };
19410     } catch (Dali::DaliException e) {
19411       {
19412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19413       };
19414     } catch (...) {
19415       {
19416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19417       };
19418     }
19419   }
19420
19421   jresult = (void *)result;
19422   return jresult;
19423 }
19424
19425
19426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19427   void * jresult ;
19428   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19429   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19430
19431   arg1 = (Dali::ObjectRegistry *)jarg1;
19432   {
19433     try {
19434       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19435     } catch (std::out_of_range& e) {
19436       {
19437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19438       };
19439     } catch (std::exception& e) {
19440       {
19441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19442       };
19443     } catch (Dali::DaliException e) {
19444       {
19445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19446       };
19447     } catch (...) {
19448       {
19449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19450       };
19451     }
19452   }
19453
19454   jresult = (void *)result;
19455   return jresult;
19456 }
19457
19458
19459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19460   void * jresult ;
19461   Dali::PropertyCondition *result = 0 ;
19462
19463   {
19464     try {
19465       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19466     } catch (std::out_of_range& e) {
19467       {
19468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19469       };
19470     } catch (std::exception& e) {
19471       {
19472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19473       };
19474     } catch (Dali::DaliException e) {
19475       {
19476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19477       };
19478     } catch (...) {
19479       {
19480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19481       };
19482     }
19483   }
19484
19485   jresult = (void *)result;
19486   return jresult;
19487 }
19488
19489
19490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19491   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19492
19493   arg1 = (Dali::PropertyCondition *)jarg1;
19494   {
19495     try {
19496       delete arg1;
19497     } catch (std::out_of_range& e) {
19498       {
19499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19500       };
19501     } catch (std::exception& e) {
19502       {
19503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19504       };
19505     } catch (Dali::DaliException e) {
19506       {
19507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19508       };
19509     } catch (...) {
19510       {
19511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19512       };
19513     }
19514   }
19515
19516 }
19517
19518
19519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19520   void * jresult ;
19521   Dali::PropertyCondition *arg1 = 0 ;
19522   Dali::PropertyCondition *result = 0 ;
19523
19524   arg1 = (Dali::PropertyCondition *)jarg1;
19525   if (!arg1) {
19526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19527     return 0;
19528   }
19529   {
19530     try {
19531       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19532     } catch (std::out_of_range& e) {
19533       {
19534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19535       };
19536     } catch (std::exception& e) {
19537       {
19538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19539       };
19540     } catch (Dali::DaliException e) {
19541       {
19542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19543       };
19544     } catch (...) {
19545       {
19546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19547       };
19548     }
19549   }
19550
19551   jresult = (void *)result;
19552   return jresult;
19553 }
19554
19555
19556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19557   void * jresult ;
19558   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19559   Dali::PropertyCondition *arg2 = 0 ;
19560   Dali::PropertyCondition *result = 0 ;
19561
19562   arg1 = (Dali::PropertyCondition *)jarg1;
19563   arg2 = (Dali::PropertyCondition *)jarg2;
19564   if (!arg2) {
19565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19566     return 0;
19567   }
19568   {
19569     try {
19570       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19571     } catch (std::out_of_range& e) {
19572       {
19573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19574       };
19575     } catch (std::exception& e) {
19576       {
19577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19578       };
19579     } catch (Dali::DaliException e) {
19580       {
19581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19582       };
19583     } catch (...) {
19584       {
19585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19586       };
19587     }
19588   }
19589
19590   jresult = (void *)result;
19591   return jresult;
19592 }
19593
19594
19595 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19596   unsigned long jresult ;
19597   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19598   std::size_t result;
19599
19600   arg1 = (Dali::PropertyCondition *)jarg1;
19601   {
19602     try {
19603       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19604     } catch (std::out_of_range& e) {
19605       {
19606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19607       };
19608     } catch (std::exception& e) {
19609       {
19610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19611       };
19612     } catch (...) {
19613       {
19614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19615       };
19616     }
19617   }
19618   jresult = (unsigned long)result;
19619   return jresult;
19620 }
19621
19622
19623 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19624   float jresult ;
19625   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19626   std::size_t arg2 ;
19627   float result;
19628
19629   arg1 = (Dali::PropertyCondition *)jarg1;
19630   arg2 = (std::size_t)jarg2;
19631   {
19632     try {
19633       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19634     } catch (std::out_of_range& e) {
19635       {
19636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19637       };
19638     } catch (std::exception& e) {
19639       {
19640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19641       };
19642     } catch (...) {
19643       {
19644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19645       };
19646     }
19647   }
19648   jresult = result;
19649   return jresult;
19650 }
19651
19652
19653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19654   void * jresult ;
19655   float arg1 ;
19656   Dali::PropertyCondition result;
19657
19658   arg1 = (float)jarg1;
19659   {
19660     try {
19661       result = Dali::LessThanCondition(arg1);
19662     } catch (std::out_of_range& e) {
19663       {
19664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19665       };
19666     } catch (std::exception& e) {
19667       {
19668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19669       };
19670     } catch (Dali::DaliException e) {
19671       {
19672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19673       };
19674     } catch (...) {
19675       {
19676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19677       };
19678     }
19679   }
19680
19681   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19682   return jresult;
19683 }
19684
19685
19686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19687   void * jresult ;
19688   float arg1 ;
19689   Dali::PropertyCondition result;
19690
19691   arg1 = (float)jarg1;
19692   {
19693     try {
19694       result = Dali::GreaterThanCondition(arg1);
19695     } catch (std::out_of_range& e) {
19696       {
19697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19698       };
19699     } catch (std::exception& e) {
19700       {
19701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19702       };
19703     } catch (Dali::DaliException e) {
19704       {
19705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19706       };
19707     } catch (...) {
19708       {
19709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19710       };
19711     }
19712   }
19713
19714   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19715   return jresult;
19716 }
19717
19718
19719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19720   void * jresult ;
19721   float arg1 ;
19722   float arg2 ;
19723   Dali::PropertyCondition result;
19724
19725   arg1 = (float)jarg1;
19726   arg2 = (float)jarg2;
19727   {
19728     try {
19729       result = Dali::InsideCondition(arg1,arg2);
19730     } catch (std::out_of_range& e) {
19731       {
19732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19733       };
19734     } catch (std::exception& e) {
19735       {
19736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19737       };
19738     } catch (Dali::DaliException e) {
19739       {
19740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19741       };
19742     } catch (...) {
19743       {
19744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19745       };
19746     }
19747   }
19748
19749   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19750   return jresult;
19751 }
19752
19753
19754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19755   void * jresult ;
19756   float arg1 ;
19757   float arg2 ;
19758   Dali::PropertyCondition result;
19759
19760   arg1 = (float)jarg1;
19761   arg2 = (float)jarg2;
19762   {
19763     try {
19764       result = Dali::OutsideCondition(arg1,arg2);
19765     } catch (std::out_of_range& e) {
19766       {
19767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19768       };
19769     } catch (std::exception& e) {
19770       {
19771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19772       };
19773     } catch (Dali::DaliException e) {
19774       {
19775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19776       };
19777     } catch (...) {
19778       {
19779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19780       };
19781     }
19782   }
19783
19784   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19785   return jresult;
19786 }
19787
19788
19789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19790   void * jresult ;
19791   float arg1 ;
19792   float arg2 ;
19793   Dali::PropertyCondition result;
19794
19795   arg1 = (float)jarg1;
19796   arg2 = (float)jarg2;
19797   {
19798     try {
19799       result = Dali::StepCondition(arg1,arg2);
19800     } catch (std::out_of_range& e) {
19801       {
19802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19803       };
19804     } catch (std::exception& e) {
19805       {
19806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19807       };
19808     } catch (Dali::DaliException e) {
19809       {
19810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19811       };
19812     } catch (...) {
19813       {
19814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19815       };
19816     }
19817   }
19818
19819   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19820   return jresult;
19821 }
19822
19823
19824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19825   void * jresult ;
19826   float arg1 ;
19827   Dali::PropertyCondition result;
19828
19829   arg1 = (float)jarg1;
19830   {
19831     try {
19832       result = Dali::StepCondition(arg1);
19833     } catch (std::out_of_range& e) {
19834       {
19835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19836       };
19837     } catch (std::exception& e) {
19838       {
19839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19840       };
19841     } catch (Dali::DaliException e) {
19842       {
19843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19844       };
19845     } catch (...) {
19846       {
19847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19848       };
19849     }
19850   }
19851
19852   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19853   return jresult;
19854 }
19855
19856
19857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19858   void * jresult ;
19859   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19860   Dali::PropertyCondition result;
19861
19862   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19863   if (!arg1) {
19864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19865     return 0;
19866   }
19867   {
19868     try {
19869       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19870     } catch (std::out_of_range& e) {
19871       {
19872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19873       };
19874     } catch (std::exception& e) {
19875       {
19876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19877       };
19878     } catch (Dali::DaliException e) {
19879       {
19880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19881       };
19882     } catch (...) {
19883       {
19884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19885       };
19886     }
19887   }
19888
19889   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19890   return jresult;
19891 }
19892
19893
19894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19895   void * jresult ;
19896   Dali::PropertyNotification *result = 0 ;
19897
19898   {
19899     try {
19900       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19901     } catch (std::out_of_range& e) {
19902       {
19903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19904       };
19905     } catch (std::exception& e) {
19906       {
19907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19908       };
19909     } catch (Dali::DaliException e) {
19910       {
19911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19912       };
19913     } catch (...) {
19914       {
19915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19916       };
19917     }
19918   }
19919
19920   jresult = (void *)result;
19921   return jresult;
19922 }
19923
19924
19925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19926   void * jresult ;
19927   Dali::BaseHandle arg1 ;
19928   Dali::BaseHandle *argp1 ;
19929   Dali::PropertyNotification result;
19930
19931   argp1 = (Dali::BaseHandle *)jarg1;
19932   if (!argp1) {
19933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19934     return 0;
19935   }
19936   arg1 = *argp1;
19937   {
19938     try {
19939       result = Dali::PropertyNotification::DownCast(arg1);
19940     } catch (std::out_of_range& e) {
19941       {
19942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19943       };
19944     } catch (std::exception& e) {
19945       {
19946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19947       };
19948     } catch (Dali::DaliException e) {
19949       {
19950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19951       };
19952     } catch (...) {
19953       {
19954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19955       };
19956     }
19957   }
19958
19959   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19960   return jresult;
19961 }
19962
19963
19964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19965   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19966
19967   arg1 = (Dali::PropertyNotification *)jarg1;
19968   {
19969     try {
19970       delete arg1;
19971     } catch (std::out_of_range& e) {
19972       {
19973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19974       };
19975     } catch (std::exception& e) {
19976       {
19977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19978       };
19979     } catch (Dali::DaliException e) {
19980       {
19981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19982       };
19983     } catch (...) {
19984       {
19985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19986       };
19987     }
19988   }
19989
19990 }
19991
19992
19993 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19994   void * jresult ;
19995   Dali::PropertyNotification *arg1 = 0 ;
19996   Dali::PropertyNotification *result = 0 ;
19997
19998   arg1 = (Dali::PropertyNotification *)jarg1;
19999   if (!arg1) {
20000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20001     return 0;
20002   }
20003   {
20004     try {
20005       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
20006     } catch (std::out_of_range& e) {
20007       {
20008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20009       };
20010     } catch (std::exception& e) {
20011       {
20012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20013       };
20014     } catch (Dali::DaliException e) {
20015       {
20016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20017       };
20018     } catch (...) {
20019       {
20020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20021       };
20022     }
20023   }
20024
20025   jresult = (void *)result;
20026   return jresult;
20027 }
20028
20029
20030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
20031   void * jresult ;
20032   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20033   Dali::PropertyNotification *arg2 = 0 ;
20034   Dali::PropertyNotification *result = 0 ;
20035
20036   arg1 = (Dali::PropertyNotification *)jarg1;
20037   arg2 = (Dali::PropertyNotification *)jarg2;
20038   if (!arg2) {
20039     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
20040     return 0;
20041   }
20042   {
20043     try {
20044       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
20045     } catch (std::out_of_range& e) {
20046       {
20047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20048       };
20049     } catch (std::exception& e) {
20050       {
20051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20052       };
20053     } catch (Dali::DaliException e) {
20054       {
20055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20056       };
20057     } catch (...) {
20058       {
20059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20060       };
20061     }
20062   }
20063
20064   jresult = (void *)result;
20065   return jresult;
20066 }
20067
20068
20069 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20070   void * jresult ;
20071   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20072   Dali::PropertyCondition result;
20073
20074   arg1 = (Dali::PropertyNotification *)jarg1;
20075   {
20076     try {
20077       result = (arg1)->GetCondition();
20078     } catch (std::out_of_range& e) {
20079       {
20080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20081       };
20082     } catch (std::exception& e) {
20083       {
20084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20085       };
20086     } catch (Dali::DaliException e) {
20087       {
20088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20089       };
20090     } catch (...) {
20091       {
20092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20093       };
20094     }
20095   }
20096
20097   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20098   return jresult;
20099 }
20100
20101
20102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20103   void * jresult ;
20104   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20105   Dali::Handle result;
20106
20107   arg1 = (Dali::PropertyNotification *)jarg1;
20108   {
20109     try {
20110       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20111     } catch (std::out_of_range& e) {
20112       {
20113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20114       };
20115     } catch (std::exception& e) {
20116       {
20117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20118       };
20119     } catch (Dali::DaliException e) {
20120       {
20121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20122       };
20123     } catch (...) {
20124       {
20125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20126       };
20127     }
20128   }
20129
20130   jresult = new Dali::Handle((const Dali::Handle &)result);
20131   return jresult;
20132 }
20133
20134
20135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20136   int jresult ;
20137   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20138   Dali::Property::Index result;
20139
20140   arg1 = (Dali::PropertyNotification *)jarg1;
20141   {
20142     try {
20143       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20144     } catch (std::out_of_range& e) {
20145       {
20146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20147       };
20148     } catch (std::exception& e) {
20149       {
20150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20151       };
20152     } catch (Dali::DaliException e) {
20153       {
20154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20155       };
20156     } catch (...) {
20157       {
20158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20159       };
20160     }
20161   }
20162
20163   jresult = result;
20164   return jresult;
20165 }
20166
20167
20168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20169   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20170   Dali::PropertyNotification::NotifyMode arg2 ;
20171
20172   arg1 = (Dali::PropertyNotification *)jarg1;
20173   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20174   {
20175     try {
20176       (arg1)->SetNotifyMode(arg2);
20177     } catch (std::out_of_range& e) {
20178       {
20179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20180       };
20181     } catch (std::exception& e) {
20182       {
20183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20184       };
20185     } catch (Dali::DaliException e) {
20186       {
20187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20188       };
20189     } catch (...) {
20190       {
20191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20192       };
20193     }
20194   }
20195
20196 }
20197
20198
20199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20200   int jresult ;
20201   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20202   Dali::PropertyNotification::NotifyMode result;
20203
20204   arg1 = (Dali::PropertyNotification *)jarg1;
20205   {
20206     try {
20207       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20208     } catch (std::out_of_range& e) {
20209       {
20210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20211       };
20212     } catch (std::exception& e) {
20213       {
20214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20215       };
20216     } catch (Dali::DaliException e) {
20217       {
20218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20219       };
20220     } catch (...) {
20221       {
20222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20223       };
20224     }
20225   }
20226
20227   jresult = (int)result;
20228   return jresult;
20229 }
20230
20231
20232 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20233   unsigned int jresult ;
20234   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20235   bool result;
20236
20237   arg1 = (Dali::PropertyNotification *)jarg1;
20238   {
20239     try {
20240       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20241     } catch (std::out_of_range& e) {
20242       {
20243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20244       };
20245     } catch (std::exception& e) {
20246       {
20247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20248       };
20249     } catch (Dali::DaliException e) {
20250       {
20251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20252       };
20253     } catch (...) {
20254       {
20255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20256       };
20257     }
20258   }
20259
20260   jresult = result;
20261   return jresult;
20262 }
20263
20264
20265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20266   void * jresult ;
20267   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20268   Dali::PropertyNotifySignalType *result = 0 ;
20269
20270   arg1 = (Dali::PropertyNotification *)jarg1;
20271   {
20272     try {
20273       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20274     } catch (std::out_of_range& e) {
20275       {
20276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20277       };
20278     } catch (std::exception& e) {
20279       {
20280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20281       };
20282     } catch (Dali::DaliException e) {
20283       {
20284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20285       };
20286     } catch (...) {
20287       {
20288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20289       };
20290     }
20291   }
20292
20293   jresult = (void *)result;
20294   return jresult;
20295 }
20296
20297
20298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20299   void * jresult ;
20300   Dali::Handle *result = 0 ;
20301
20302   {
20303     try {
20304       result = (Dali::Handle *)new Dali::Handle();
20305     } catch (std::out_of_range& e) {
20306       {
20307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20308       };
20309     } catch (std::exception& e) {
20310       {
20311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20312       };
20313     } catch (Dali::DaliException e) {
20314       {
20315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20316       };
20317     } catch (...) {
20318       {
20319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20320       };
20321     }
20322   }
20323
20324   jresult = (void *)result;
20325   return jresult;
20326 }
20327
20328
20329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20330   void * jresult ;
20331   Dali::Handle result;
20332
20333   {
20334     try {
20335       result = Dali::Handle::New();
20336     } catch (std::out_of_range& e) {
20337       {
20338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20339       };
20340     } catch (std::exception& e) {
20341       {
20342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20343       };
20344     } catch (Dali::DaliException e) {
20345       {
20346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20347       };
20348     } catch (...) {
20349       {
20350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20351       };
20352     }
20353   }
20354
20355   jresult = new Dali::Handle((const Dali::Handle &)result);
20356   return jresult;
20357 }
20358
20359
20360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20361   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20362
20363   arg1 = (Dali::Handle *)jarg1;
20364   {
20365     try {
20366       delete arg1;
20367     } catch (std::out_of_range& e) {
20368       {
20369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20370       };
20371     } catch (std::exception& e) {
20372       {
20373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20374       };
20375     } catch (Dali::DaliException e) {
20376       {
20377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20378       };
20379     } catch (...) {
20380       {
20381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20382       };
20383     }
20384   }
20385
20386 }
20387
20388
20389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20390   void * jresult ;
20391   Dali::Handle *arg1 = 0 ;
20392   Dali::Handle *result = 0 ;
20393
20394   arg1 = (Dali::Handle *)jarg1;
20395   if (!arg1) {
20396     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20397     return 0;
20398   }
20399   {
20400     try {
20401       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20402     } catch (std::out_of_range& e) {
20403       {
20404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20405       };
20406     } catch (std::exception& e) {
20407       {
20408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20409       };
20410     } catch (Dali::DaliException e) {
20411       {
20412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20413       };
20414     } catch (...) {
20415       {
20416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20417       };
20418     }
20419   }
20420
20421   jresult = (void *)result;
20422   return jresult;
20423 }
20424
20425
20426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20427   void * jresult ;
20428   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20429   Dali::Handle *arg2 = 0 ;
20430   Dali::Handle *result = 0 ;
20431
20432   arg1 = (Dali::Handle *)jarg1;
20433   arg2 = (Dali::Handle *)jarg2;
20434   if (!arg2) {
20435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20436     return 0;
20437   }
20438   {
20439     try {
20440       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20441     } catch (std::out_of_range& e) {
20442       {
20443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20444       };
20445     } catch (std::exception& e) {
20446       {
20447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20448       };
20449     } catch (Dali::DaliException e) {
20450       {
20451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20452       };
20453     } catch (...) {
20454       {
20455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20456       };
20457     }
20458   }
20459
20460   jresult = (void *)result;
20461   return jresult;
20462 }
20463
20464
20465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20466   void * jresult ;
20467   Dali::BaseHandle arg1 ;
20468   Dali::BaseHandle *argp1 ;
20469   Dali::Handle result;
20470
20471   argp1 = (Dali::BaseHandle *)jarg1;
20472   if (!argp1) {
20473     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20474     return 0;
20475   }
20476   arg1 = *argp1;
20477   {
20478     try {
20479       result = Dali::Handle::DownCast(arg1);
20480     } catch (std::out_of_range& e) {
20481       {
20482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20483       };
20484     } catch (std::exception& e) {
20485       {
20486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20487       };
20488     } catch (Dali::DaliException e) {
20489       {
20490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20491       };
20492     } catch (...) {
20493       {
20494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20495       };
20496     }
20497   }
20498
20499   jresult = new Dali::Handle((const Dali::Handle &)result);
20500   return jresult;
20501 }
20502
20503
20504 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20505   unsigned int jresult ;
20506   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20507   Dali::Handle::Capability arg2 ;
20508   bool result;
20509
20510   arg1 = (Dali::Handle *)jarg1;
20511   arg2 = (Dali::Handle::Capability)jarg2;
20512   {
20513     try {
20514       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20515     } catch (std::out_of_range& e) {
20516       {
20517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20518       };
20519     } catch (std::exception& e) {
20520       {
20521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20522       };
20523     } catch (Dali::DaliException e) {
20524       {
20525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20526       };
20527     } catch (...) {
20528       {
20529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20530       };
20531     }
20532   }
20533
20534   jresult = result;
20535   return jresult;
20536 }
20537
20538
20539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20540   unsigned int jresult ;
20541   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20542   unsigned int result;
20543
20544   arg1 = (Dali::Handle *)jarg1;
20545   {
20546     try {
20547       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20548     } catch (std::out_of_range& e) {
20549       {
20550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20551       };
20552     } catch (std::exception& e) {
20553       {
20554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20555       };
20556     } catch (Dali::DaliException e) {
20557       {
20558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20559       };
20560     } catch (...) {
20561       {
20562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20563       };
20564     }
20565   }
20566
20567   jresult = result;
20568   return jresult;
20569 }
20570
20571
20572 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20573   char * jresult ;
20574   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20575   Dali::Property::Index arg2 ;
20576   std::string result;
20577
20578   arg1 = (Dali::Handle *)jarg1;
20579   arg2 = (Dali::Property::Index)jarg2;
20580   {
20581     try {
20582       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20583     } catch (std::out_of_range& e) {
20584       {
20585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20586       };
20587     } catch (std::exception& e) {
20588       {
20589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20590       };
20591     } catch (Dali::DaliException e) {
20592       {
20593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20594       };
20595     } catch (...) {
20596       {
20597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20598       };
20599     }
20600   }
20601
20602   jresult = SWIG_csharp_string_callback((&result)->c_str());
20603   return jresult;
20604 }
20605
20606
20607 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20608   int jresult ;
20609   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20610   std::string *arg2 = 0 ;
20611   Dali::Property::Index result;
20612
20613   arg1 = (Dali::Handle *)jarg1;
20614   if (!jarg2) {
20615     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20616     return 0;
20617   }
20618   std::string arg2_str(jarg2);
20619   arg2 = &arg2_str;
20620   {
20621     try {
20622       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20623     } catch (std::out_of_range& e) {
20624       {
20625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20626       };
20627     } catch (std::exception& e) {
20628       {
20629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20630       };
20631     } catch (Dali::DaliException e) {
20632       {
20633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20634       };
20635     } catch (...) {
20636       {
20637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20638       };
20639     }
20640   }
20641
20642   jresult = result;
20643
20644   //argout typemap for const std::string&
20645
20646   return jresult;
20647 }
20648
20649
20650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20651   unsigned int jresult ;
20652   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20653   Dali::Property::Index arg2 ;
20654   bool result;
20655
20656   arg1 = (Dali::Handle *)jarg1;
20657   arg2 = (Dali::Property::Index)jarg2;
20658   {
20659     try {
20660       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20661     } catch (std::out_of_range& e) {
20662       {
20663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20664       };
20665     } catch (std::exception& e) {
20666       {
20667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20668       };
20669     } catch (Dali::DaliException e) {
20670       {
20671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20672       };
20673     } catch (...) {
20674       {
20675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20676       };
20677     }
20678   }
20679
20680   jresult = result;
20681   return jresult;
20682 }
20683
20684
20685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20686   unsigned int jresult ;
20687   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20688   Dali::Property::Index arg2 ;
20689   bool result;
20690
20691   arg1 = (Dali::Handle *)jarg1;
20692   arg2 = (Dali::Property::Index)jarg2;
20693   {
20694     try {
20695       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20696     } catch (std::out_of_range& e) {
20697       {
20698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20699       };
20700     } catch (std::exception& e) {
20701       {
20702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20703       };
20704     } catch (Dali::DaliException e) {
20705       {
20706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20707       };
20708     } catch (...) {
20709       {
20710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20711       };
20712     }
20713   }
20714
20715   jresult = result;
20716   return jresult;
20717 }
20718
20719
20720 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20721   unsigned int jresult ;
20722   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20723   Dali::Property::Index arg2 ;
20724   bool result;
20725
20726   arg1 = (Dali::Handle *)jarg1;
20727   arg2 = (Dali::Property::Index)jarg2;
20728   {
20729     try {
20730       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20731     } catch (std::out_of_range& e) {
20732       {
20733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20734       };
20735     } catch (std::exception& e) {
20736       {
20737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20738       };
20739     } catch (Dali::DaliException e) {
20740       {
20741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20742       };
20743     } catch (...) {
20744       {
20745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20746       };
20747     }
20748   }
20749
20750   jresult = result;
20751   return jresult;
20752 }
20753
20754
20755 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20756   int jresult ;
20757   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20758   Dali::Property::Index arg2 ;
20759   Dali::Property::Type result;
20760
20761   arg1 = (Dali::Handle *)jarg1;
20762   arg2 = (Dali::Property::Index)jarg2;
20763   {
20764     try {
20765       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20766     } catch (std::out_of_range& e) {
20767       {
20768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20769       };
20770     } catch (std::exception& e) {
20771       {
20772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20773       };
20774     } catch (Dali::DaliException e) {
20775       {
20776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20777       };
20778     } catch (...) {
20779       {
20780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20781       };
20782     }
20783   }
20784
20785   jresult = (int)result;
20786   return jresult;
20787 }
20788
20789
20790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20791   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20792   Dali::Property::Index arg2 ;
20793   Dali::Property::Value *arg3 = 0 ;
20794
20795   arg1 = (Dali::Handle *)jarg1;
20796   arg2 = (Dali::Property::Index)jarg2;
20797   arg3 = (Dali::Property::Value *)jarg3;
20798   if (!arg3) {
20799     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20800     return ;
20801   }
20802   {
20803     try {
20804       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20805     } catch (std::out_of_range& e) {
20806       {
20807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20808       };
20809     } catch (std::exception& e) {
20810       {
20811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20812       };
20813     } catch (Dali::DaliException e) {
20814       {
20815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20816       };
20817     } catch (...) {
20818       {
20819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20820       };
20821     }
20822   }
20823
20824 }
20825
20826
20827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20828   int jresult ;
20829   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20830   std::string *arg2 = 0 ;
20831   Dali::Property::Value *arg3 = 0 ;
20832   Dali::Property::Index result;
20833
20834   arg1 = (Dali::Handle *)jarg1;
20835   if (!jarg2) {
20836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20837     return 0;
20838   }
20839   std::string arg2_str(jarg2);
20840   arg2 = &arg2_str;
20841   arg3 = (Dali::Property::Value *)jarg3;
20842   if (!arg3) {
20843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20844     return 0;
20845   }
20846   {
20847     try {
20848       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20849     } catch (std::out_of_range& e) {
20850       {
20851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20852       };
20853     } catch (std::exception& e) {
20854       {
20855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20856       };
20857     } catch (Dali::DaliException e) {
20858       {
20859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20860       };
20861     } catch (...) {
20862       {
20863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20864       };
20865     }
20866   }
20867
20868   jresult = result;
20869
20870   //argout typemap for const std::string&
20871
20872   return jresult;
20873 }
20874
20875
20876 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20877   int jresult ;
20878   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20879   std::string *arg2 = 0 ;
20880   Dali::Property::Value *arg3 = 0 ;
20881   Dali::Property::AccessMode arg4 ;
20882   Dali::Property::Index result;
20883
20884   arg1 = (Dali::Handle *)jarg1;
20885   if (!jarg2) {
20886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20887     return 0;
20888   }
20889   std::string arg2_str(jarg2);
20890   arg2 = &arg2_str;
20891   arg3 = (Dali::Property::Value *)jarg3;
20892   if (!arg3) {
20893     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20894     return 0;
20895   }
20896   arg4 = (Dali::Property::AccessMode)jarg4;
20897   {
20898     try {
20899       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20900     } catch (std::out_of_range& e) {
20901       {
20902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20903       };
20904     } catch (std::exception& e) {
20905       {
20906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20907       };
20908     } catch (Dali::DaliException e) {
20909       {
20910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20911       };
20912     } catch (...) {
20913       {
20914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20915       };
20916     }
20917   }
20918
20919   jresult = result;
20920
20921   //argout typemap for const std::string&
20922
20923   return jresult;
20924 }
20925
20926
20927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20928   void * jresult ;
20929   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20930   Dali::Property::Index arg2 ;
20931   Dali::Property::Value result;
20932
20933   arg1 = (Dali::Handle *)jarg1;
20934   arg2 = (Dali::Property::Index)jarg2;
20935   {
20936     try {
20937       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20938     } catch (std::out_of_range& e) {
20939       {
20940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20941       };
20942     } catch (std::exception& e) {
20943       {
20944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20945       };
20946     } catch (Dali::DaliException e) {
20947       {
20948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20949       };
20950     } catch (...) {
20951       {
20952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20953       };
20954     }
20955   }
20956
20957   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20958   return jresult;
20959 }
20960
20961
20962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20963   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20964   Dali::Property::IndexContainer *arg2 = 0 ;
20965
20966   arg1 = (Dali::Handle *)jarg1;
20967   arg2 = (Dali::Property::IndexContainer *)jarg2;
20968   if (!arg2) {
20969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20970     return ;
20971   }
20972   {
20973     try {
20974       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20975     } catch (std::out_of_range& e) {
20976       {
20977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20978       };
20979     } catch (std::exception& e) {
20980       {
20981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20982       };
20983     } catch (Dali::DaliException e) {
20984       {
20985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20986       };
20987     } catch (...) {
20988       {
20989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20990       };
20991     }
20992   }
20993
20994 }
20995
20996
20997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20998   void * jresult ;
20999   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21000   Dali::Property::Index arg2 ;
21001   Dali::PropertyCondition *arg3 = 0 ;
21002   Dali::PropertyNotification result;
21003
21004   arg1 = (Dali::Handle *)jarg1;
21005   arg2 = (Dali::Property::Index)jarg2;
21006   arg3 = (Dali::PropertyCondition *)jarg3;
21007   if (!arg3) {
21008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21009     return 0;
21010   }
21011   {
21012     try {
21013       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
21014     } catch (std::out_of_range& e) {
21015       {
21016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21017       };
21018     } catch (std::exception& e) {
21019       {
21020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21021       };
21022     } catch (Dali::DaliException e) {
21023       {
21024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21025       };
21026     } catch (...) {
21027       {
21028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21029       };
21030     }
21031   }
21032
21033   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21034   return jresult;
21035 }
21036
21037
21038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
21039   void * jresult ;
21040   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21041   Dali::Property::Index arg2 ;
21042   int arg3 ;
21043   Dali::PropertyCondition *arg4 = 0 ;
21044   Dali::PropertyNotification result;
21045
21046   arg1 = (Dali::Handle *)jarg1;
21047   arg2 = (Dali::Property::Index)jarg2;
21048   arg3 = (int)jarg3;
21049   arg4 = (Dali::PropertyCondition *)jarg4;
21050   if (!arg4) {
21051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
21052     return 0;
21053   }
21054   {
21055     try {
21056       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21057     } catch (std::out_of_range& e) {
21058       {
21059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21060       };
21061     } catch (std::exception& e) {
21062       {
21063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21064       };
21065     } catch (Dali::DaliException e) {
21066       {
21067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21068       };
21069     } catch (...) {
21070       {
21071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21072       };
21073     }
21074   }
21075
21076   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21077   return jresult;
21078 }
21079
21080
21081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21082   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21083   Dali::PropertyNotification arg2 ;
21084   Dali::PropertyNotification *argp2 ;
21085
21086   arg1 = (Dali::Handle *)jarg1;
21087   argp2 = (Dali::PropertyNotification *)jarg2;
21088   if (!argp2) {
21089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21090     return ;
21091   }
21092   arg2 = *argp2;
21093   {
21094     try {
21095       (arg1)->RemovePropertyNotification(arg2);
21096     } catch (std::out_of_range& e) {
21097       {
21098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21099       };
21100     } catch (std::exception& e) {
21101       {
21102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21103       };
21104     } catch (Dali::DaliException e) {
21105       {
21106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21107       };
21108     } catch (...) {
21109       {
21110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21111       };
21112     }
21113   }
21114
21115 }
21116
21117
21118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21119   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21120
21121   arg1 = (Dali::Handle *)jarg1;
21122   {
21123     try {
21124       (arg1)->RemovePropertyNotifications();
21125     } catch (std::out_of_range& e) {
21126       {
21127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21128       };
21129     } catch (std::exception& e) {
21130       {
21131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21132       };
21133     } catch (Dali::DaliException e) {
21134       {
21135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21136       };
21137     } catch (...) {
21138       {
21139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21140       };
21141     }
21142   }
21143
21144 }
21145
21146
21147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21148   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21149
21150   arg1 = (Dali::Handle *)jarg1;
21151   {
21152     try {
21153       (arg1)->RemoveConstraints();
21154     } catch (std::out_of_range& e) {
21155       {
21156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21157       };
21158     } catch (std::exception& e) {
21159       {
21160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21161       };
21162     } catch (Dali::DaliException e) {
21163       {
21164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21165       };
21166     } catch (...) {
21167       {
21168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21169       };
21170     }
21171   }
21172
21173 }
21174
21175
21176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21177   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21178   unsigned int arg2 ;
21179
21180   arg1 = (Dali::Handle *)jarg1;
21181   arg2 = (unsigned int)jarg2;
21182   {
21183     try {
21184       (arg1)->RemoveConstraints(arg2);
21185     } catch (std::out_of_range& e) {
21186       {
21187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21188       };
21189     } catch (std::exception& e) {
21190       {
21191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21192       };
21193     } catch (Dali::DaliException e) {
21194       {
21195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21196       };
21197     } catch (...) {
21198       {
21199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21200       };
21201     }
21202   }
21203
21204 }
21205
21206
21207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21208   int jresult ;
21209   Dali::Property::Index result;
21210
21211   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21212   jresult = result;
21213   return jresult;
21214 }
21215
21216
21217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21218   void * jresult ;
21219   Dali::Handle result;
21220
21221   {
21222     try {
21223       result = Dali::WeightObject::New();
21224     } catch (std::out_of_range& e) {
21225       {
21226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21227       };
21228     } catch (std::exception& e) {
21229       {
21230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21231       };
21232     } catch (Dali::DaliException e) {
21233       {
21234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21235       };
21236     } catch (...) {
21237       {
21238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21239       };
21240     }
21241   }
21242
21243   jresult = new Dali::Handle((const Dali::Handle &)result);
21244   return jresult;
21245 }
21246
21247
21248 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21249   void * jresult ;
21250   Dali::TypeInfo *result = 0 ;
21251
21252   {
21253     try {
21254       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21255     } catch (std::out_of_range& e) {
21256       {
21257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21258       };
21259     } catch (std::exception& e) {
21260       {
21261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21262       };
21263     } catch (Dali::DaliException e) {
21264       {
21265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21266       };
21267     } catch (...) {
21268       {
21269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21270       };
21271     }
21272   }
21273
21274   jresult = (void *)result;
21275   return jresult;
21276 }
21277
21278
21279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21280   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21281
21282   arg1 = (Dali::TypeInfo *)jarg1;
21283   {
21284     try {
21285       delete arg1;
21286     } catch (std::out_of_range& e) {
21287       {
21288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21289       };
21290     } catch (std::exception& e) {
21291       {
21292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21293       };
21294     } catch (Dali::DaliException e) {
21295       {
21296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21297       };
21298     } catch (...) {
21299       {
21300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21301       };
21302     }
21303   }
21304
21305 }
21306
21307
21308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21309   void * jresult ;
21310   Dali::TypeInfo *arg1 = 0 ;
21311   Dali::TypeInfo *result = 0 ;
21312
21313   arg1 = (Dali::TypeInfo *)jarg1;
21314   if (!arg1) {
21315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21316     return 0;
21317   }
21318   {
21319     try {
21320       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21321     } catch (std::out_of_range& e) {
21322       {
21323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21324       };
21325     } catch (std::exception& e) {
21326       {
21327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21328       };
21329     } catch (Dali::DaliException e) {
21330       {
21331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21332       };
21333     } catch (...) {
21334       {
21335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21336       };
21337     }
21338   }
21339
21340   jresult = (void *)result;
21341   return jresult;
21342 }
21343
21344
21345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21346   void * jresult ;
21347   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21348   Dali::TypeInfo *arg2 = 0 ;
21349   Dali::TypeInfo *result = 0 ;
21350
21351   arg1 = (Dali::TypeInfo *)jarg1;
21352   arg2 = (Dali::TypeInfo *)jarg2;
21353   if (!arg2) {
21354     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21355     return 0;
21356   }
21357   {
21358     try {
21359       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21360     } catch (std::out_of_range& e) {
21361       {
21362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21363       };
21364     } catch (std::exception& e) {
21365       {
21366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21367       };
21368     } catch (Dali::DaliException e) {
21369       {
21370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21371       };
21372     } catch (...) {
21373       {
21374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21375       };
21376     }
21377   }
21378
21379   jresult = (void *)result;
21380   return jresult;
21381 }
21382
21383
21384 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21385   char * jresult ;
21386   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21387   std::string *result = 0 ;
21388
21389   arg1 = (Dali::TypeInfo *)jarg1;
21390   {
21391     try {
21392       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21393     } catch (std::out_of_range& e) {
21394       {
21395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21396       };
21397     } catch (std::exception& e) {
21398       {
21399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21400       };
21401     } catch (Dali::DaliException e) {
21402       {
21403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21404       };
21405     } catch (...) {
21406       {
21407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21408       };
21409     }
21410   }
21411
21412   jresult = SWIG_csharp_string_callback(result->c_str());
21413   return jresult;
21414 }
21415
21416
21417 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21418   char * jresult ;
21419   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21420   std::string *result = 0 ;
21421
21422   arg1 = (Dali::TypeInfo *)jarg1;
21423   {
21424     try {
21425       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21426     } catch (std::out_of_range& e) {
21427       {
21428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21429       };
21430     } catch (std::exception& e) {
21431       {
21432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21433       };
21434     } catch (Dali::DaliException e) {
21435       {
21436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21437       };
21438     } catch (...) {
21439       {
21440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21441       };
21442     }
21443   }
21444
21445   jresult = SWIG_csharp_string_callback(result->c_str());
21446   return jresult;
21447 }
21448
21449
21450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21451   void * jresult ;
21452   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21453   Dali::BaseHandle result;
21454
21455   arg1 = (Dali::TypeInfo *)jarg1;
21456   {
21457     try {
21458       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21459     } catch (std::out_of_range& e) {
21460       {
21461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21462       };
21463     } catch (std::exception& e) {
21464       {
21465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21466       };
21467     } catch (Dali::DaliException e) {
21468       {
21469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21470       };
21471     } catch (...) {
21472       {
21473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21474       };
21475     }
21476   }
21477
21478   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21479   return jresult;
21480 }
21481
21482
21483 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21484   unsigned long jresult ;
21485   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21486   size_t result;
21487
21488   arg1 = (Dali::TypeInfo *)jarg1;
21489   {
21490     try {
21491       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21492     } catch (std::out_of_range& e) {
21493       {
21494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21495       };
21496     } catch (std::exception& e) {
21497       {
21498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21499       };
21500     } catch (Dali::DaliException e) {
21501       {
21502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21503       };
21504     } catch (...) {
21505       {
21506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21507       };
21508     }
21509   }
21510
21511   jresult = (unsigned long)result;
21512   return jresult;
21513 }
21514
21515
21516 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21517   char * jresult ;
21518   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21519   size_t arg2 ;
21520   std::string result;
21521
21522   arg1 = (Dali::TypeInfo *)jarg1;
21523   arg2 = (size_t)jarg2;
21524   {
21525     try {
21526       result = (arg1)->GetActionName(arg2);
21527     } catch (std::out_of_range& e) {
21528       {
21529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21530       };
21531     } catch (std::exception& e) {
21532       {
21533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21534       };
21535     } catch (Dali::DaliException e) {
21536       {
21537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21538       };
21539     } catch (...) {
21540       {
21541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21542       };
21543     }
21544   }
21545
21546   jresult = SWIG_csharp_string_callback((&result)->c_str());
21547   return jresult;
21548 }
21549
21550
21551 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21552   unsigned long jresult ;
21553   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21554   size_t result;
21555
21556   arg1 = (Dali::TypeInfo *)jarg1;
21557   {
21558     try {
21559       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21560     } catch (std::out_of_range& e) {
21561       {
21562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21563       };
21564     } catch (std::exception& e) {
21565       {
21566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21567       };
21568     } catch (Dali::DaliException e) {
21569       {
21570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21571       };
21572     } catch (...) {
21573       {
21574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21575       };
21576     }
21577   }
21578
21579   jresult = (unsigned long)result;
21580   return jresult;
21581 }
21582
21583
21584 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21585   char * jresult ;
21586   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21587   size_t arg2 ;
21588   std::string result;
21589
21590   arg1 = (Dali::TypeInfo *)jarg1;
21591   arg2 = (size_t)jarg2;
21592   {
21593     try {
21594       result = (arg1)->GetSignalName(arg2);
21595     } catch (std::out_of_range& e) {
21596       {
21597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21598       };
21599     } catch (std::exception& e) {
21600       {
21601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21602       };
21603     } catch (Dali::DaliException e) {
21604       {
21605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21606       };
21607     } catch (...) {
21608       {
21609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21610       };
21611     }
21612   }
21613
21614   jresult = SWIG_csharp_string_callback((&result)->c_str());
21615   return jresult;
21616 }
21617
21618
21619 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21620   unsigned long jresult ;
21621   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21622   size_t result;
21623
21624   arg1 = (Dali::TypeInfo *)jarg1;
21625   {
21626     try {
21627       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21628     } catch (std::out_of_range& e) {
21629       {
21630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21631       };
21632     } catch (std::exception& e) {
21633       {
21634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21635       };
21636     } catch (Dali::DaliException e) {
21637       {
21638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21639       };
21640     } catch (...) {
21641       {
21642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21643       };
21644     }
21645   }
21646
21647   jresult = (unsigned long)result;
21648   return jresult;
21649 }
21650
21651
21652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21653   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21654   Dali::Property::IndexContainer *arg2 = 0 ;
21655
21656   arg1 = (Dali::TypeInfo *)jarg1;
21657   arg2 = (Dali::Property::IndexContainer *)jarg2;
21658   if (!arg2) {
21659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21660     return ;
21661   }
21662   {
21663     try {
21664       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21665     } catch (std::out_of_range& e) {
21666       {
21667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21668       };
21669     } catch (std::exception& e) {
21670       {
21671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21672       };
21673     } catch (Dali::DaliException e) {
21674       {
21675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21676       };
21677     } catch (...) {
21678       {
21679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21680       };
21681     }
21682   }
21683
21684 }
21685
21686
21687 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21688   char * jresult ;
21689   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21690   Dali::Property::Index arg2 ;
21691   std::string *result = 0 ;
21692
21693   arg1 = (Dali::TypeInfo *)jarg1;
21694   arg2 = (Dali::Property::Index)jarg2;
21695   {
21696     try {
21697       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21698     } catch (std::out_of_range& e) {
21699       {
21700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21701       };
21702     } catch (std::exception& e) {
21703       {
21704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21705       };
21706     } catch (Dali::DaliException e) {
21707       {
21708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21709       };
21710     } catch (...) {
21711       {
21712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21713       };
21714     }
21715   }
21716
21717   jresult = SWIG_csharp_string_callback(result->c_str());
21718   return jresult;
21719 }
21720
21721
21722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21723   void * jresult ;
21724   Dali::TypeRegistry result;
21725
21726   {
21727     try {
21728       result = Dali::TypeRegistry::Get();
21729     } catch (std::out_of_range& e) {
21730       {
21731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21732       };
21733     } catch (std::exception& e) {
21734       {
21735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21736       };
21737     } catch (Dali::DaliException e) {
21738       {
21739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21740       };
21741     } catch (...) {
21742       {
21743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21744       };
21745     }
21746   }
21747
21748   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21749   return jresult;
21750 }
21751
21752
21753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21754   void * jresult ;
21755   Dali::TypeRegistry *result = 0 ;
21756
21757   {
21758     try {
21759       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21760     } catch (std::out_of_range& e) {
21761       {
21762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21763       };
21764     } catch (std::exception& e) {
21765       {
21766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21767       };
21768     } catch (Dali::DaliException e) {
21769       {
21770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21771       };
21772     } catch (...) {
21773       {
21774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21775       };
21776     }
21777   }
21778
21779   jresult = (void *)result;
21780   return jresult;
21781 }
21782
21783
21784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21785   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21786
21787   arg1 = (Dali::TypeRegistry *)jarg1;
21788   {
21789     try {
21790       delete arg1;
21791     } catch (std::out_of_range& e) {
21792       {
21793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21794       };
21795     } catch (std::exception& e) {
21796       {
21797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21798       };
21799     } catch (Dali::DaliException e) {
21800       {
21801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21802       };
21803     } catch (...) {
21804       {
21805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21806       };
21807     }
21808   }
21809
21810 }
21811
21812
21813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21814   void * jresult ;
21815   Dali::TypeRegistry *arg1 = 0 ;
21816   Dali::TypeRegistry *result = 0 ;
21817
21818   arg1 = (Dali::TypeRegistry *)jarg1;
21819   if (!arg1) {
21820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21821     return 0;
21822   }
21823   {
21824     try {
21825       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21826     } catch (std::out_of_range& e) {
21827       {
21828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21829       };
21830     } catch (std::exception& e) {
21831       {
21832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21833       };
21834     } catch (Dali::DaliException e) {
21835       {
21836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21837       };
21838     } catch (...) {
21839       {
21840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21841       };
21842     }
21843   }
21844
21845   jresult = (void *)result;
21846   return jresult;
21847 }
21848
21849
21850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21851   void * jresult ;
21852   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21853   Dali::TypeRegistry *arg2 = 0 ;
21854   Dali::TypeRegistry *result = 0 ;
21855
21856   arg1 = (Dali::TypeRegistry *)jarg1;
21857   arg2 = (Dali::TypeRegistry *)jarg2;
21858   if (!arg2) {
21859     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21860     return 0;
21861   }
21862   {
21863     try {
21864       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21865     } catch (std::out_of_range& e) {
21866       {
21867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21868       };
21869     } catch (std::exception& e) {
21870       {
21871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21872       };
21873     } catch (Dali::DaliException e) {
21874       {
21875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21876       };
21877     } catch (...) {
21878       {
21879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21880       };
21881     }
21882   }
21883
21884   jresult = (void *)result;
21885   return jresult;
21886 }
21887
21888
21889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21890   void * jresult ;
21891   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21892   std::string *arg2 = 0 ;
21893   Dali::TypeInfo result;
21894
21895   arg1 = (Dali::TypeRegistry *)jarg1;
21896   if (!jarg2) {
21897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21898     return 0;
21899   }
21900   std::string arg2_str(jarg2);
21901   arg2 = &arg2_str;
21902   {
21903     try {
21904       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21905     } catch (std::out_of_range& e) {
21906       {
21907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21908       };
21909     } catch (std::exception& e) {
21910       {
21911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21912       };
21913     } catch (Dali::DaliException e) {
21914       {
21915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21916       };
21917     } catch (...) {
21918       {
21919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21920       };
21921     }
21922   }
21923
21924   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21925
21926   //argout typemap for const std::string&
21927
21928   return jresult;
21929 }
21930
21931
21932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21933   void * jresult ;
21934   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21935   std::type_info *arg2 = 0 ;
21936   Dali::TypeInfo result;
21937
21938   arg1 = (Dali::TypeRegistry *)jarg1;
21939   arg2 = (std::type_info *)jarg2;
21940   if (!arg2) {
21941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21942     return 0;
21943   }
21944   {
21945     try {
21946       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21947     } catch (std::out_of_range& e) {
21948       {
21949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21950       };
21951     } catch (std::exception& e) {
21952       {
21953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21954       };
21955     } catch (Dali::DaliException e) {
21956       {
21957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21958       };
21959     } catch (...) {
21960       {
21961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21962       };
21963     }
21964   }
21965
21966   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21967   return jresult;
21968 }
21969
21970
21971 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21972   unsigned long jresult ;
21973   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21974   size_t result;
21975
21976   arg1 = (Dali::TypeRegistry *)jarg1;
21977   {
21978     try {
21979       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21980     } catch (std::out_of_range& e) {
21981       {
21982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21983       };
21984     } catch (std::exception& e) {
21985       {
21986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21987       };
21988     } catch (Dali::DaliException e) {
21989       {
21990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21991       };
21992     } catch (...) {
21993       {
21994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21995       };
21996     }
21997   }
21998
21999   jresult = (unsigned long)result;
22000   return jresult;
22001 }
22002
22003
22004 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
22005   char * jresult ;
22006   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
22007   size_t arg2 ;
22008   std::string result;
22009
22010   arg1 = (Dali::TypeRegistry *)jarg1;
22011   arg2 = (size_t)jarg2;
22012   {
22013     try {
22014       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
22015     } catch (std::out_of_range& e) {
22016       {
22017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22018       };
22019     } catch (std::exception& e) {
22020       {
22021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22022       };
22023     } catch (Dali::DaliException e) {
22024       {
22025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22026       };
22027     } catch (...) {
22028       {
22029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22030       };
22031     }
22032   }
22033
22034   jresult = SWIG_csharp_string_callback((&result)->c_str());
22035   return jresult;
22036 }
22037
22038
22039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
22040   void * jresult ;
22041   std::type_info *arg1 = 0 ;
22042   std::type_info *arg2 = 0 ;
22043   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22044   Dali::TypeRegistration *result = 0 ;
22045
22046   arg1 = (std::type_info *)jarg1;
22047   if (!arg1) {
22048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22049     return 0;
22050   }
22051   arg2 = (std::type_info *)jarg2;
22052   if (!arg2) {
22053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22054     return 0;
22055   }
22056   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22057   {
22058     try {
22059       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22060     } catch (std::out_of_range& e) {
22061       {
22062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22063       };
22064     } catch (std::exception& e) {
22065       {
22066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22067       };
22068     } catch (Dali::DaliException e) {
22069       {
22070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22071       };
22072     } catch (...) {
22073       {
22074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22075       };
22076     }
22077   }
22078
22079   jresult = (void *)result;
22080   return jresult;
22081 }
22082
22083
22084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22085   void * jresult ;
22086   std::type_info *arg1 = 0 ;
22087   std::type_info *arg2 = 0 ;
22088   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22089   bool arg4 ;
22090   Dali::TypeRegistration *result = 0 ;
22091
22092   arg1 = (std::type_info *)jarg1;
22093   if (!arg1) {
22094     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22095     return 0;
22096   }
22097   arg2 = (std::type_info *)jarg2;
22098   if (!arg2) {
22099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22100     return 0;
22101   }
22102   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22103   arg4 = jarg4 ? true : false;
22104   {
22105     try {
22106       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22107     } catch (std::out_of_range& e) {
22108       {
22109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22110       };
22111     } catch (std::exception& e) {
22112       {
22113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22114       };
22115     } catch (Dali::DaliException e) {
22116       {
22117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22118       };
22119     } catch (...) {
22120       {
22121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22122       };
22123     }
22124   }
22125
22126   jresult = (void *)result;
22127   return jresult;
22128 }
22129
22130
22131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22132   void * jresult ;
22133   std::string *arg1 = 0 ;
22134   std::type_info *arg2 = 0 ;
22135   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22136   Dali::TypeRegistration *result = 0 ;
22137
22138   if (!jarg1) {
22139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22140     return 0;
22141   }
22142   std::string arg1_str(jarg1);
22143   arg1 = &arg1_str;
22144   arg2 = (std::type_info *)jarg2;
22145   if (!arg2) {
22146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22147     return 0;
22148   }
22149   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22150   {
22151     try {
22152       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22153     } catch (std::out_of_range& e) {
22154       {
22155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22156       };
22157     } catch (std::exception& e) {
22158       {
22159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22160       };
22161     } catch (Dali::DaliException e) {
22162       {
22163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22164       };
22165     } catch (...) {
22166       {
22167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22168       };
22169     }
22170   }
22171
22172   jresult = (void *)result;
22173
22174   //argout typemap for const std::string&
22175
22176   return jresult;
22177 }
22178
22179
22180 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22181   char * jresult ;
22182   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22183   std::string result;
22184
22185   arg1 = (Dali::TypeRegistration *)jarg1;
22186   {
22187     try {
22188       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22189     } catch (std::out_of_range& e) {
22190       {
22191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22192       };
22193     } catch (std::exception& e) {
22194       {
22195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22196       };
22197     } catch (Dali::DaliException e) {
22198       {
22199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22200       };
22201     } catch (...) {
22202       {
22203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22204       };
22205     }
22206   }
22207
22208   jresult = SWIG_csharp_string_callback((&result)->c_str());
22209   return jresult;
22210 }
22211
22212
22213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22214   std::string *arg1 = 0 ;
22215   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22216
22217   if (!jarg1) {
22218     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22219     return ;
22220   }
22221   std::string arg1_str(jarg1);
22222   arg1 = &arg1_str;
22223   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22224   {
22225     try {
22226       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22227     } catch (std::out_of_range& e) {
22228       {
22229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22230       };
22231     } catch (std::exception& e) {
22232       {
22233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22234       };
22235     } catch (Dali::DaliException e) {
22236       {
22237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22238       };
22239     } catch (...) {
22240       {
22241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22242       };
22243     }
22244   }
22245
22246
22247   //argout typemap for const std::string&
22248
22249 }
22250
22251
22252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22253   std::string *arg1 = 0 ;
22254   std::string *arg2 = 0 ;
22255   int arg3 ;
22256   Dali::Property::Type arg4 ;
22257   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22258   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22259
22260   if (!jarg1) {
22261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22262     return ;
22263   }
22264   std::string arg1_str(jarg1);
22265   arg1 = &arg1_str;
22266   if (!jarg2) {
22267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22268     return ;
22269   }
22270   std::string arg2_str(jarg2);
22271   arg2 = &arg2_str;
22272   arg3 = (int)jarg3;
22273   arg4 = (Dali::Property::Type)jarg4;
22274   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22275   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22276   {
22277     try {
22278       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22279     } catch (std::out_of_range& e) {
22280       {
22281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22282       };
22283     } catch (std::exception& e) {
22284       {
22285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22286       };
22287     } catch (Dali::DaliException e) {
22288       {
22289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22290       };
22291     } catch (...) {
22292       {
22293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22294       };
22295     }
22296   }
22297
22298
22299   //argout typemap for const std::string&
22300
22301
22302   //argout typemap for const std::string&
22303
22304 }
22305
22306
22307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22308   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22309
22310   arg1 = (Dali::TypeRegistration *)jarg1;
22311   {
22312     try {
22313       delete arg1;
22314     } catch (std::out_of_range& e) {
22315       {
22316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22317       };
22318     } catch (std::exception& e) {
22319       {
22320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22321       };
22322     } catch (Dali::DaliException e) {
22323       {
22324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22325       };
22326     } catch (...) {
22327       {
22328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22329       };
22330     }
22331   }
22332
22333 }
22334
22335
22336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22337   void * jresult ;
22338   Dali::TypeRegistration *arg1 = 0 ;
22339   std::string *arg2 = 0 ;
22340   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22341   Dali::SignalConnectorType *result = 0 ;
22342
22343   arg1 = (Dali::TypeRegistration *)jarg1;
22344   if (!arg1) {
22345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22346     return 0;
22347   }
22348   if (!jarg2) {
22349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22350     return 0;
22351   }
22352   std::string arg2_str(jarg2);
22353   arg2 = &arg2_str;
22354   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22355   {
22356     try {
22357       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22358     } catch (std::out_of_range& e) {
22359       {
22360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22361       };
22362     } catch (std::exception& e) {
22363       {
22364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22365       };
22366     } catch (Dali::DaliException e) {
22367       {
22368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22369       };
22370     } catch (...) {
22371       {
22372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22373       };
22374     }
22375   }
22376
22377   jresult = (void *)result;
22378
22379   //argout typemap for const std::string&
22380
22381   return jresult;
22382 }
22383
22384
22385 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22386   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22387
22388   arg1 = (Dali::SignalConnectorType *)jarg1;
22389   {
22390     try {
22391       delete arg1;
22392     } catch (std::out_of_range& e) {
22393       {
22394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22395       };
22396     } catch (std::exception& e) {
22397       {
22398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22399       };
22400     } catch (Dali::DaliException e) {
22401       {
22402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22403       };
22404     } catch (...) {
22405       {
22406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22407       };
22408     }
22409   }
22410
22411 }
22412
22413
22414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22415   void * jresult ;
22416   Dali::TypeRegistration *arg1 = 0 ;
22417   std::string *arg2 = 0 ;
22418   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22419   Dali::TypeAction *result = 0 ;
22420
22421   arg1 = (Dali::TypeRegistration *)jarg1;
22422   if (!arg1) {
22423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22424     return 0;
22425   }
22426   if (!jarg2) {
22427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22428     return 0;
22429   }
22430   std::string arg2_str(jarg2);
22431   arg2 = &arg2_str;
22432   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22433   {
22434     try {
22435       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22436     } catch (std::out_of_range& e) {
22437       {
22438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22439       };
22440     } catch (std::exception& e) {
22441       {
22442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22443       };
22444     } catch (Dali::DaliException e) {
22445       {
22446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22447       };
22448     } catch (...) {
22449       {
22450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22451       };
22452     }
22453   }
22454
22455   jresult = (void *)result;
22456
22457   //argout typemap for const std::string&
22458
22459   return jresult;
22460 }
22461
22462
22463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22464   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22465
22466   arg1 = (Dali::TypeAction *)jarg1;
22467   {
22468     try {
22469       delete arg1;
22470     } catch (std::out_of_range& e) {
22471       {
22472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22473       };
22474     } catch (std::exception& e) {
22475       {
22476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22477       };
22478     } catch (Dali::DaliException e) {
22479       {
22480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22481       };
22482     } catch (...) {
22483       {
22484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22485       };
22486     }
22487   }
22488
22489 }
22490
22491
22492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22493   void * jresult ;
22494   Dali::TypeRegistration *arg1 = 0 ;
22495   std::string *arg2 = 0 ;
22496   Dali::Property::Index arg3 ;
22497   Dali::Property::Type arg4 ;
22498   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22499   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22500   Dali::PropertyRegistration *result = 0 ;
22501
22502   arg1 = (Dali::TypeRegistration *)jarg1;
22503   if (!arg1) {
22504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22505     return 0;
22506   }
22507   if (!jarg2) {
22508     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22509     return 0;
22510   }
22511   std::string arg2_str(jarg2);
22512   arg2 = &arg2_str;
22513   arg3 = (Dali::Property::Index)jarg3;
22514   arg4 = (Dali::Property::Type)jarg4;
22515   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22516   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22517   {
22518     try {
22519       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
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 (Dali::DaliException e) {
22529       {
22530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22531       };
22532     } catch (...) {
22533       {
22534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22535       };
22536     }
22537   }
22538
22539   jresult = (void *)result;
22540
22541   //argout typemap for const std::string&
22542
22543   return jresult;
22544 }
22545
22546
22547 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22548   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22549
22550   arg1 = (Dali::PropertyRegistration *)jarg1;
22551   {
22552     try {
22553       delete arg1;
22554     } catch (std::out_of_range& e) {
22555       {
22556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22557       };
22558     } catch (std::exception& e) {
22559       {
22560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22561       };
22562     } catch (Dali::DaliException e) {
22563       {
22564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22565       };
22566     } catch (...) {
22567       {
22568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22569       };
22570     }
22571   }
22572
22573 }
22574
22575
22576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22577   void * jresult ;
22578   Dali::TypeRegistration *arg1 = 0 ;
22579   std::string *arg2 = 0 ;
22580   Dali::Property::Index arg3 ;
22581   Dali::Property::Type arg4 ;
22582   Dali::AnimatablePropertyRegistration *result = 0 ;
22583
22584   arg1 = (Dali::TypeRegistration *)jarg1;
22585   if (!arg1) {
22586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22587     return 0;
22588   }
22589   if (!jarg2) {
22590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22591     return 0;
22592   }
22593   std::string arg2_str(jarg2);
22594   arg2 = &arg2_str;
22595   arg3 = (Dali::Property::Index)jarg3;
22596   arg4 = (Dali::Property::Type)jarg4;
22597   {
22598     try {
22599       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22600     } catch (std::out_of_range& e) {
22601       {
22602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22603       };
22604     } catch (std::exception& e) {
22605       {
22606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22607       };
22608     } catch (Dali::DaliException e) {
22609       {
22610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22611       };
22612     } catch (...) {
22613       {
22614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22615       };
22616     }
22617   }
22618
22619   jresult = (void *)result;
22620
22621   //argout typemap for const std::string&
22622
22623   return jresult;
22624 }
22625
22626
22627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22628   void * jresult ;
22629   Dali::TypeRegistration *arg1 = 0 ;
22630   std::string *arg2 = 0 ;
22631   Dali::Property::Index arg3 ;
22632   Dali::Property::Value *arg4 = 0 ;
22633   Dali::AnimatablePropertyRegistration *result = 0 ;
22634
22635   arg1 = (Dali::TypeRegistration *)jarg1;
22636   if (!arg1) {
22637     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22638     return 0;
22639   }
22640   if (!jarg2) {
22641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22642     return 0;
22643   }
22644   std::string arg2_str(jarg2);
22645   arg2 = &arg2_str;
22646   arg3 = (Dali::Property::Index)jarg3;
22647   arg4 = (Dali::Property::Value *)jarg4;
22648   if (!arg4) {
22649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22650     return 0;
22651   }
22652   {
22653     try {
22654       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22655     } catch (std::out_of_range& e) {
22656       {
22657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22658       };
22659     } catch (std::exception& e) {
22660       {
22661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22662       };
22663     } catch (Dali::DaliException e) {
22664       {
22665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22666       };
22667     } catch (...) {
22668       {
22669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22670       };
22671     }
22672   }
22673
22674   jresult = (void *)result;
22675
22676   //argout typemap for const std::string&
22677
22678   return jresult;
22679 }
22680
22681
22682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22683   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22684
22685   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22686   {
22687     try {
22688       delete arg1;
22689     } catch (std::out_of_range& e) {
22690       {
22691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22692       };
22693     } catch (std::exception& e) {
22694       {
22695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22696       };
22697     } catch (Dali::DaliException e) {
22698       {
22699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22700       };
22701     } catch (...) {
22702       {
22703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22704       };
22705     }
22706   }
22707
22708 }
22709
22710
22711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22712   void * jresult ;
22713   Dali::TypeRegistration *arg1 = 0 ;
22714   std::string *arg2 = 0 ;
22715   Dali::Property::Index arg3 ;
22716   Dali::Property::Index arg4 ;
22717   unsigned int arg5 ;
22718   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22719
22720   arg1 = (Dali::TypeRegistration *)jarg1;
22721   if (!arg1) {
22722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22723     return 0;
22724   }
22725   if (!jarg2) {
22726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22727     return 0;
22728   }
22729   std::string arg2_str(jarg2);
22730   arg2 = &arg2_str;
22731   arg3 = (Dali::Property::Index)jarg3;
22732   arg4 = (Dali::Property::Index)jarg4;
22733   arg5 = (unsigned int)jarg5;
22734   {
22735     try {
22736       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22737     } catch (std::out_of_range& e) {
22738       {
22739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22740       };
22741     } catch (std::exception& e) {
22742       {
22743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22744       };
22745     } catch (Dali::DaliException e) {
22746       {
22747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22748       };
22749     } catch (...) {
22750       {
22751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22752       };
22753     }
22754   }
22755
22756   jresult = (void *)result;
22757
22758   //argout typemap for const std::string&
22759
22760   return jresult;
22761 }
22762
22763
22764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22765   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22766
22767   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22768   {
22769     try {
22770       delete arg1;
22771     } catch (std::out_of_range& e) {
22772       {
22773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22774       };
22775     } catch (std::exception& e) {
22776       {
22777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22778       };
22779     } catch (Dali::DaliException e) {
22780       {
22781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22782       };
22783     } catch (...) {
22784       {
22785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22786       };
22787     }
22788   }
22789
22790 }
22791
22792
22793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22794   void * jresult ;
22795   Dali::TypeRegistration *arg1 = 0 ;
22796   std::string *arg2 = 0 ;
22797   Dali::Property::Index arg3 ;
22798   Dali::Property::Type arg4 ;
22799   Dali::ChildPropertyRegistration *result = 0 ;
22800
22801   arg1 = (Dali::TypeRegistration *)jarg1;
22802   if (!arg1) {
22803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22804     return 0;
22805   }
22806   if (!jarg2) {
22807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22808     return 0;
22809   }
22810   std::string arg2_str(jarg2);
22811   arg2 = &arg2_str;
22812   arg3 = (Dali::Property::Index)jarg3;
22813   arg4 = (Dali::Property::Type)jarg4;
22814   {
22815     try {
22816       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22817     } catch (std::out_of_range& e) {
22818       {
22819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22820       };
22821     } catch (std::exception& e) {
22822       {
22823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22824       };
22825     } catch (Dali::DaliException e) {
22826       {
22827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22828       };
22829     } catch (...) {
22830       {
22831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22832       };
22833     }
22834   }
22835
22836   jresult = (void *)result;
22837
22838   //argout typemap for const std::string&
22839
22840   return jresult;
22841 }
22842
22843
22844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22845   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22846
22847   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22848   {
22849     try {
22850       delete arg1;
22851     } catch (std::out_of_range& e) {
22852       {
22853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22854       };
22855     } catch (std::exception& e) {
22856       {
22857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22858       };
22859     } catch (Dali::DaliException e) {
22860       {
22861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22862       };
22863     } catch (...) {
22864       {
22865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22866       };
22867     }
22868   }
22869
22870 }
22871
22872
22873 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22874   unsigned int jresult ;
22875   std::string *arg1 = 0 ;
22876   std::type_info *arg2 = 0 ;
22877   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22878   bool result;
22879
22880   if (!jarg1) {
22881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22882     return 0;
22883   }
22884   std::string arg1_str(jarg1);
22885   arg1 = &arg1_str;
22886   arg2 = (std::type_info *)jarg2;
22887   if (!arg2) {
22888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22889     return 0;
22890   }
22891   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22892   {
22893     try {
22894       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22895     } catch (std::out_of_range& e) {
22896       {
22897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22898       };
22899     } catch (std::exception& e) {
22900       {
22901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22902       };
22903     } catch (Dali::DaliException e) {
22904       {
22905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22906       };
22907     } catch (...) {
22908       {
22909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22910       };
22911     }
22912   }
22913
22914   jresult = result;
22915
22916   //argout typemap for const std::string&
22917
22918   return jresult;
22919 }
22920
22921
22922 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22923   unsigned int jresult ;
22924   std::string *arg1 = 0 ;
22925   std::string *arg2 = 0 ;
22926   Dali::Property::Index arg3 ;
22927   Dali::Property::Type arg4 ;
22928   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22929   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22930   bool result;
22931
22932   if (!jarg1) {
22933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22934     return 0;
22935   }
22936   std::string arg1_str(jarg1);
22937   arg1 = &arg1_str;
22938   if (!jarg2) {
22939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22940     return 0;
22941   }
22942   std::string arg2_str(jarg2);
22943   arg2 = &arg2_str;
22944   arg3 = (Dali::Property::Index)jarg3;
22945   arg4 = (Dali::Property::Type)jarg4;
22946   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22947   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22948   {
22949     try {
22950       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22951     } catch (std::out_of_range& e) {
22952       {
22953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22954       };
22955     } catch (std::exception& e) {
22956       {
22957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22958       };
22959     } catch (Dali::DaliException e) {
22960       {
22961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22962       };
22963     } catch (...) {
22964       {
22965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22966       };
22967     }
22968   }
22969
22970   jresult = result;
22971
22972   //argout typemap for const std::string&
22973
22974
22975   //argout typemap for const std::string&
22976
22977   return jresult;
22978 }
22979
22980
22981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22982   float jresult ;
22983   float result;
22984
22985   result = (float)(float)Dali::ParentOrigin::TOP;
22986   jresult = result;
22987   return jresult;
22988 }
22989
22990
22991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22992   float jresult ;
22993   float result;
22994
22995   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22996   jresult = result;
22997   return jresult;
22998 }
22999
23000
23001 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
23002   float jresult ;
23003   float result;
23004
23005   result = (float)(float)Dali::ParentOrigin::LEFT;
23006   jresult = result;
23007   return jresult;
23008 }
23009
23010
23011 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
23012   float jresult ;
23013   float result;
23014
23015   result = (float)(float)Dali::ParentOrigin::RIGHT;
23016   jresult = result;
23017   return jresult;
23018 }
23019
23020
23021 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
23022   float jresult ;
23023   float result;
23024
23025   result = (float)(float)Dali::ParentOrigin::MIDDLE;
23026   jresult = result;
23027   return jresult;
23028 }
23029
23030
23031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
23032   void * jresult ;
23033   Dali::Vector3 *result = 0 ;
23034
23035   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
23036   jresult = (void *)result;
23037   return jresult;
23038 }
23039
23040
23041 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
23042   void * jresult ;
23043   Dali::Vector3 *result = 0 ;
23044
23045   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
23046   jresult = (void *)result;
23047   return jresult;
23048 }
23049
23050
23051 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
23052   void * jresult ;
23053   Dali::Vector3 *result = 0 ;
23054
23055   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23056   jresult = (void *)result;
23057   return jresult;
23058 }
23059
23060
23061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23062   void * jresult ;
23063   Dali::Vector3 *result = 0 ;
23064
23065   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23066   jresult = (void *)result;
23067   return jresult;
23068 }
23069
23070
23071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23072   void * jresult ;
23073   Dali::Vector3 *result = 0 ;
23074
23075   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23076   jresult = (void *)result;
23077   return jresult;
23078 }
23079
23080
23081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23082   void * jresult ;
23083   Dali::Vector3 *result = 0 ;
23084
23085   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23086   jresult = (void *)result;
23087   return jresult;
23088 }
23089
23090
23091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23092   void * jresult ;
23093   Dali::Vector3 *result = 0 ;
23094
23095   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23096   jresult = (void *)result;
23097   return jresult;
23098 }
23099
23100
23101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23102   void * jresult ;
23103   Dali::Vector3 *result = 0 ;
23104
23105   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23106   jresult = (void *)result;
23107   return jresult;
23108 }
23109
23110
23111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23112   void * jresult ;
23113   Dali::Vector3 *result = 0 ;
23114
23115   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23116   jresult = (void *)result;
23117   return jresult;
23118 }
23119
23120
23121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23122   float jresult ;
23123   float result;
23124
23125   result = (float)(float)Dali::AnchorPoint::TOP;
23126   jresult = result;
23127   return jresult;
23128 }
23129
23130
23131 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23132   float jresult ;
23133   float result;
23134
23135   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23136   jresult = result;
23137   return jresult;
23138 }
23139
23140
23141 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23142   float jresult ;
23143   float result;
23144
23145   result = (float)(float)Dali::AnchorPoint::LEFT;
23146   jresult = result;
23147   return jresult;
23148 }
23149
23150
23151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23152   float jresult ;
23153   float result;
23154
23155   result = (float)(float)Dali::AnchorPoint::RIGHT;
23156   jresult = result;
23157   return jresult;
23158 }
23159
23160
23161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23162   float jresult ;
23163   float result;
23164
23165   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23166   jresult = result;
23167   return jresult;
23168 }
23169
23170
23171 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23172   void * jresult ;
23173   Dali::Vector3 *result = 0 ;
23174
23175   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23176   jresult = (void *)result;
23177   return jresult;
23178 }
23179
23180
23181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23182   void * jresult ;
23183   Dali::Vector3 *result = 0 ;
23184
23185   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23186   jresult = (void *)result;
23187   return jresult;
23188 }
23189
23190
23191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23192   void * jresult ;
23193   Dali::Vector3 *result = 0 ;
23194
23195   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23196   jresult = (void *)result;
23197   return jresult;
23198 }
23199
23200
23201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23202   void * jresult ;
23203   Dali::Vector3 *result = 0 ;
23204
23205   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23206   jresult = (void *)result;
23207   return jresult;
23208 }
23209
23210
23211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23212   void * jresult ;
23213   Dali::Vector3 *result = 0 ;
23214
23215   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23216   jresult = (void *)result;
23217   return jresult;
23218 }
23219
23220
23221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23222   void * jresult ;
23223   Dali::Vector3 *result = 0 ;
23224
23225   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23226   jresult = (void *)result;
23227   return jresult;
23228 }
23229
23230
23231 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23232   void * jresult ;
23233   Dali::Vector3 *result = 0 ;
23234
23235   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23236   jresult = (void *)result;
23237   return jresult;
23238 }
23239
23240
23241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23242   void * jresult ;
23243   Dali::Vector3 *result = 0 ;
23244
23245   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23246   jresult = (void *)result;
23247   return jresult;
23248 }
23249
23250
23251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23252   void * jresult ;
23253   Dali::Vector3 *result = 0 ;
23254
23255   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23256   jresult = (void *)result;
23257   return jresult;
23258 }
23259
23260
23261 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23262   void * jresult ;
23263   Dali::Vector4 *result = 0 ;
23264
23265   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23266   jresult = (void *)result;
23267   return jresult;
23268 }
23269
23270
23271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23272   void * jresult ;
23273   Dali::Vector4 *result = 0 ;
23274
23275   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23276   jresult = (void *)result;
23277   return jresult;
23278 }
23279
23280
23281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23282   void * jresult ;
23283   Dali::Vector4 *result = 0 ;
23284
23285   result = (Dali::Vector4 *)&Dali::Color::RED;
23286   jresult = (void *)result;
23287   return jresult;
23288 }
23289
23290
23291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23292   void * jresult ;
23293   Dali::Vector4 *result = 0 ;
23294
23295   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23296   jresult = (void *)result;
23297   return jresult;
23298 }
23299
23300
23301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23302   void * jresult ;
23303   Dali::Vector4 *result = 0 ;
23304
23305   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23306   jresult = (void *)result;
23307   return jresult;
23308 }
23309
23310
23311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23312   void * jresult ;
23313   Dali::Vector4 *result = 0 ;
23314
23315   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23316   jresult = (void *)result;
23317   return jresult;
23318 }
23319
23320
23321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23322   void * jresult ;
23323   Dali::Vector4 *result = 0 ;
23324
23325   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23326   jresult = (void *)result;
23327   return jresult;
23328 }
23329
23330
23331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23332   void * jresult ;
23333   Dali::Vector4 *result = 0 ;
23334
23335   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23336   jresult = (void *)result;
23337   return jresult;
23338 }
23339
23340
23341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23342   void * jresult ;
23343   Dali::Vector4 *result = 0 ;
23344
23345   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23346   jresult = (void *)result;
23347   return jresult;
23348 }
23349
23350
23351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23352   float jresult ;
23353   float result;
23354
23355   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23356   jresult = result;
23357   return jresult;
23358 }
23359
23360
23361 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23362   float jresult ;
23363   float result;
23364
23365   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23366   jresult = result;
23367   return jresult;
23368 }
23369
23370
23371 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23372   float jresult ;
23373   float result;
23374
23375   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23376   jresult = result;
23377   return jresult;
23378 }
23379
23380
23381 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23382   float jresult ;
23383   float result;
23384
23385   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23386   jresult = result;
23387   return jresult;
23388 }
23389
23390
23391 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23392   float jresult ;
23393   float result;
23394
23395   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23396   jresult = result;
23397   return jresult;
23398 }
23399
23400
23401 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23402   float jresult ;
23403   float result;
23404
23405   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23406   jresult = result;
23407   return jresult;
23408 }
23409
23410
23411 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23412   float jresult ;
23413   float result;
23414
23415   result = (float)(float)Dali::Math::PI;
23416   jresult = result;
23417   return jresult;
23418 }
23419
23420
23421 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23422   float jresult ;
23423   float result;
23424
23425   result = (float)(float)Dali::Math::PI_2;
23426   jresult = result;
23427   return jresult;
23428 }
23429
23430
23431 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23432   float jresult ;
23433   float result;
23434
23435   result = (float)(float)Dali::Math::PI_4;
23436   jresult = result;
23437   return jresult;
23438 }
23439
23440
23441 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23442   float jresult ;
23443   float result;
23444
23445   result = (float)(float)Dali::Math::PI_OVER_180;
23446   jresult = result;
23447   return jresult;
23448 }
23449
23450
23451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23452   float jresult ;
23453   float result;
23454
23455   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23456   jresult = result;
23457   return jresult;
23458 }
23459
23460
23461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23462   int jresult ;
23463   Dali::ResizePolicy::Type result;
23464
23465   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23466   jresult = (int)result;
23467   return jresult;
23468 }
23469
23470
23471 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23472   unsigned long jresult ;
23473   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23474   Dali::VectorBase::SizeType result;
23475
23476   arg1 = (Dali::VectorBase *)jarg1;
23477   {
23478     try {
23479       result = ((Dali::VectorBase const *)arg1)->Count();
23480     } catch (std::out_of_range& e) {
23481       {
23482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23483       };
23484     } catch (std::exception& e) {
23485       {
23486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23487       };
23488     } catch (Dali::DaliException e) {
23489       {
23490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23491       };
23492     } catch (...) {
23493       {
23494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23495       };
23496     }
23497   }
23498
23499   jresult = (unsigned long)result;
23500   return jresult;
23501 }
23502
23503
23504 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23505   unsigned long jresult ;
23506   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23507   Dali::VectorBase::SizeType result;
23508
23509   arg1 = (Dali::VectorBase *)jarg1;
23510   {
23511     try {
23512       result = ((Dali::VectorBase const *)arg1)->Size();
23513     } catch (std::out_of_range& e) {
23514       {
23515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23516       };
23517     } catch (std::exception& e) {
23518       {
23519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23520       };
23521     } catch (Dali::DaliException e) {
23522       {
23523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23524       };
23525     } catch (...) {
23526       {
23527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23528       };
23529     }
23530   }
23531
23532   jresult = (unsigned long)result;
23533   return jresult;
23534 }
23535
23536
23537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23538   unsigned int jresult ;
23539   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23540   bool result;
23541
23542   arg1 = (Dali::VectorBase *)jarg1;
23543   {
23544     try {
23545       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23546     } catch (std::out_of_range& e) {
23547       {
23548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23549       };
23550     } catch (std::exception& e) {
23551       {
23552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23553       };
23554     } catch (Dali::DaliException e) {
23555       {
23556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23557       };
23558     } catch (...) {
23559       {
23560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23561       };
23562     }
23563   }
23564
23565   jresult = result;
23566   return jresult;
23567 }
23568
23569
23570 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23571   unsigned long jresult ;
23572   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23573   Dali::VectorBase::SizeType result;
23574
23575   arg1 = (Dali::VectorBase *)jarg1;
23576   {
23577     try {
23578       result = ((Dali::VectorBase const *)arg1)->Capacity();
23579     } catch (std::out_of_range& e) {
23580       {
23581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23582       };
23583     } catch (std::exception& e) {
23584       {
23585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23586       };
23587     } catch (Dali::DaliException e) {
23588       {
23589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23590       };
23591     } catch (...) {
23592       {
23593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23594       };
23595     }
23596   }
23597
23598   jresult = (unsigned long)result;
23599   return jresult;
23600 }
23601
23602
23603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23604   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23605
23606   arg1 = (Dali::VectorBase *)jarg1;
23607   {
23608     try {
23609       (arg1)->Release();
23610     } catch (std::out_of_range& e) {
23611       {
23612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23613       };
23614     } catch (std::exception& e) {
23615       {
23616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23617       };
23618     } catch (Dali::DaliException e) {
23619       {
23620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23621       };
23622     } catch (...) {
23623       {
23624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23625       };
23626     }
23627   }
23628
23629 }
23630
23631
23632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_0() {
23633   void * jresult ;
23634   Dali::Image *result = 0 ;
23635
23636   {
23637     try {
23638       result = (Dali::Image *)new Dali::Image();
23639     } catch (std::out_of_range& e) {
23640       {
23641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23642       };
23643     } catch (std::exception& e) {
23644       {
23645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23646       };
23647     } catch (Dali::DaliException e) {
23648       {
23649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23650       };
23651     } catch (...) {
23652       {
23653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23654       };
23655     }
23656   }
23657
23658   jresult = (void *)result;
23659   return jresult;
23660 }
23661
23662
23663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Image(void * jarg1) {
23664   Dali::Image *arg1 = (Dali::Image *) 0 ;
23665
23666   arg1 = (Dali::Image *)jarg1;
23667   {
23668     try {
23669       delete arg1;
23670     } catch (std::out_of_range& e) {
23671       {
23672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23673       };
23674     } catch (std::exception& e) {
23675       {
23676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23677       };
23678     } catch (Dali::DaliException e) {
23679       {
23680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23681       };
23682     } catch (...) {
23683       {
23684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23685       };
23686     }
23687   }
23688
23689 }
23690
23691
23692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Image__SWIG_1(void * jarg1) {
23693   void * jresult ;
23694   Dali::Image *arg1 = 0 ;
23695   Dali::Image *result = 0 ;
23696
23697   arg1 = (Dali::Image *)jarg1;
23698   if (!arg1) {
23699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23700     return 0;
23701   }
23702   {
23703     try {
23704       result = (Dali::Image *)new Dali::Image((Dali::Image const &)*arg1);
23705     } catch (std::out_of_range& e) {
23706       {
23707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23708       };
23709     } catch (std::exception& e) {
23710       {
23711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23712       };
23713     } catch (Dali::DaliException e) {
23714       {
23715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23716       };
23717     } catch (...) {
23718       {
23719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23720       };
23721     }
23722   }
23723
23724   jresult = (void *)result;
23725   return jresult;
23726 }
23727
23728
23729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_Assign(void * jarg1, void * jarg2) {
23730   void * jresult ;
23731   Dali::Image *arg1 = (Dali::Image *) 0 ;
23732   Dali::Image *arg2 = 0 ;
23733   Dali::Image *result = 0 ;
23734
23735   arg1 = (Dali::Image *)jarg1;
23736   arg2 = (Dali::Image *)jarg2;
23737   if (!arg2) {
23738     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
23739     return 0;
23740   }
23741   {
23742     try {
23743       result = (Dali::Image *) &(arg1)->operator =((Dali::Image const &)*arg2);
23744     } catch (std::out_of_range& e) {
23745       {
23746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23747       };
23748     } catch (std::exception& e) {
23749       {
23750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23751       };
23752     } catch (Dali::DaliException e) {
23753       {
23754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23755       };
23756     } catch (...) {
23757       {
23758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23759       };
23760     }
23761   }
23762
23763   jresult = (void *)result;
23764   return jresult;
23765 }
23766
23767
23768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_DownCast(void * jarg1) {
23769   void * jresult ;
23770   Dali::BaseHandle arg1 ;
23771   Dali::BaseHandle *argp1 ;
23772   Dali::Image result;
23773
23774   argp1 = (Dali::BaseHandle *)jarg1;
23775   if (!argp1) {
23776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
23777     return 0;
23778   }
23779   arg1 = *argp1;
23780   {
23781     try {
23782       result = Dali::Image::DownCast(arg1);
23783     } catch (std::out_of_range& e) {
23784       {
23785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23786       };
23787     } catch (std::exception& e) {
23788       {
23789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23790       };
23791     } catch (Dali::DaliException e) {
23792       {
23793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23794       };
23795     } catch (...) {
23796       {
23797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23798       };
23799     }
23800   }
23801
23802   jresult = new Dali::Image((const Dali::Image &)result);
23803   return jresult;
23804 }
23805
23806
23807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetWidth(void * jarg1) {
23808   unsigned int jresult ;
23809   Dali::Image *arg1 = (Dali::Image *) 0 ;
23810   unsigned int result;
23811
23812   arg1 = (Dali::Image *)jarg1;
23813   {
23814     try {
23815       result = (unsigned int)((Dali::Image const *)arg1)->GetWidth();
23816     } catch (std::out_of_range& e) {
23817       {
23818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23819       };
23820     } catch (std::exception& e) {
23821       {
23822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23823       };
23824     } catch (Dali::DaliException e) {
23825       {
23826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23827       };
23828     } catch (...) {
23829       {
23830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23831       };
23832     }
23833   }
23834
23835   jresult = result;
23836   return jresult;
23837 }
23838
23839
23840 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Image_GetHeight(void * jarg1) {
23841   unsigned int jresult ;
23842   Dali::Image *arg1 = (Dali::Image *) 0 ;
23843   unsigned int result;
23844
23845   arg1 = (Dali::Image *)jarg1;
23846   {
23847     try {
23848       result = (unsigned int)((Dali::Image const *)arg1)->GetHeight();
23849     } catch (std::out_of_range& e) {
23850       {
23851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23852       };
23853     } catch (std::exception& e) {
23854       {
23855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23856       };
23857     } catch (Dali::DaliException e) {
23858       {
23859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23860       };
23861     } catch (...) {
23862       {
23863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23864       };
23865     }
23866   }
23867
23868   jresult = result;
23869   return jresult;
23870 }
23871
23872
23873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Image_UploadedSignal(void * jarg1) {
23874   void * jresult ;
23875   Dali::Image *arg1 = (Dali::Image *) 0 ;
23876   Dali::Image::ImageSignalType *result = 0 ;
23877
23878   arg1 = (Dali::Image *)jarg1;
23879   {
23880     try {
23881       result = (Dali::Image::ImageSignalType *) &(arg1)->UploadedSignal();
23882     } catch (std::out_of_range& e) {
23883       {
23884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23885       };
23886     } catch (std::exception& e) {
23887       {
23888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23889       };
23890     } catch (Dali::DaliException e) {
23891       {
23892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23893       };
23894     } catch (...) {
23895       {
23896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23897       };
23898     }
23899   }
23900
23901   jresult = (void *)result;
23902   return jresult;
23903 }
23904
23905
23906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23907   int jresult ;
23908   Dali::Pixel::Format result;
23909
23910   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23911   jresult = (int)result;
23912   return jresult;
23913 }
23914
23915
23916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23917   int jresult ;
23918   Dali::Pixel::Format result;
23919
23920   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23921   jresult = (int)result;
23922   return jresult;
23923 }
23924
23925
23926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23927   unsigned int jresult ;
23928   Dali::Pixel::Format arg1 ;
23929   bool result;
23930
23931   arg1 = (Dali::Pixel::Format)jarg1;
23932   {
23933     try {
23934       result = (bool)Dali::Pixel::HasAlpha(arg1);
23935     } catch (std::out_of_range& e) {
23936       {
23937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23938       };
23939     } catch (std::exception& e) {
23940       {
23941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23942       };
23943     } catch (Dali::DaliException e) {
23944       {
23945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23946       };
23947     } catch (...) {
23948       {
23949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23950       };
23951     }
23952   }
23953
23954   jresult = result;
23955   return jresult;
23956 }
23957
23958
23959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23960   unsigned int jresult ;
23961   Dali::Pixel::Format arg1 ;
23962   unsigned int result;
23963
23964   arg1 = (Dali::Pixel::Format)jarg1;
23965   {
23966     try {
23967       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23968     } catch (std::out_of_range& e) {
23969       {
23970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23971       };
23972     } catch (std::exception& e) {
23973       {
23974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23975       };
23976     } catch (Dali::DaliException e) {
23977       {
23978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23979       };
23980     } catch (...) {
23981       {
23982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23983       };
23984     }
23985   }
23986
23987   jresult = result;
23988   return jresult;
23989 }
23990
23991
23992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23993   Dali::Pixel::Format arg1 ;
23994   int *arg2 = 0 ;
23995   int *arg3 = 0 ;
23996
23997   arg1 = (Dali::Pixel::Format)jarg1;
23998   arg2 = (int *)jarg2;
23999   if (!arg2) {
24000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
24001     return ;
24002   }
24003   arg3 = (int *)jarg3;
24004   if (!arg3) {
24005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
24006     return ;
24007   }
24008   {
24009     try {
24010       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
24011     } catch (std::out_of_range& e) {
24012       {
24013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24014       };
24015     } catch (std::exception& e) {
24016       {
24017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24018       };
24019     } catch (Dali::DaliException e) {
24020       {
24021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24022       };
24023     } catch (...) {
24024       {
24025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24026       };
24027     }
24028   }
24029
24030 }
24031
24032
24033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
24034   void * jresult ;
24035   unsigned char *arg1 = (unsigned char *) 0 ;
24036   unsigned int arg2 ;
24037   unsigned int arg3 ;
24038   unsigned int arg4 ;
24039   Dali::Pixel::Format arg5 ;
24040   Dali::PixelData::ReleaseFunction arg6 ;
24041   Dali::PixelData result;
24042
24043   arg1 = jarg1;
24044   arg2 = (unsigned int)jarg2;
24045   arg3 = (unsigned int)jarg3;
24046   arg4 = (unsigned int)jarg4;
24047   arg5 = (Dali::Pixel::Format)jarg5;
24048   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
24049   {
24050     try {
24051       auto pixelBuffer = new unsigned char[jarg2];
24052       memcpy( pixelBuffer, arg1, arg2);
24053       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
24054     } catch (std::out_of_range& e) {
24055       {
24056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24057       };
24058     } catch (std::exception& e) {
24059       {
24060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24061       };
24062     } catch (Dali::DaliException e) {
24063       {
24064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24065       };
24066     } catch (...) {
24067       {
24068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24069       };
24070     }
24071   }
24072
24073   jresult = new Dali::PixelData((const Dali::PixelData &)result);
24074
24075
24076   return jresult;
24077 }
24078
24079
24080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
24081   void * jresult ;
24082   Dali::PixelData *result = 0 ;
24083
24084   {
24085     try {
24086       result = (Dali::PixelData *)new Dali::PixelData();
24087     } catch (std::out_of_range& e) {
24088       {
24089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24090       };
24091     } catch (std::exception& e) {
24092       {
24093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24094       };
24095     } catch (Dali::DaliException e) {
24096       {
24097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24098       };
24099     } catch (...) {
24100       {
24101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24102       };
24103     }
24104   }
24105
24106   jresult = (void *)result;
24107   return jresult;
24108 }
24109
24110
24111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
24112   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24113
24114   arg1 = (Dali::PixelData *)jarg1;
24115   {
24116     try {
24117       delete arg1;
24118     } catch (std::out_of_range& e) {
24119       {
24120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24121       };
24122     } catch (std::exception& e) {
24123       {
24124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24125       };
24126     } catch (Dali::DaliException e) {
24127       {
24128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24129       };
24130     } catch (...) {
24131       {
24132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24133       };
24134     }
24135   }
24136
24137 }
24138
24139
24140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
24141   void * jresult ;
24142   Dali::PixelData *arg1 = 0 ;
24143   Dali::PixelData *result = 0 ;
24144
24145   arg1 = (Dali::PixelData *)jarg1;
24146   if (!arg1) {
24147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24148     return 0;
24149   }
24150   {
24151     try {
24152       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
24153     } catch (std::out_of_range& e) {
24154       {
24155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24156       };
24157     } catch (std::exception& e) {
24158       {
24159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24160       };
24161     } catch (Dali::DaliException e) {
24162       {
24163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24164       };
24165     } catch (...) {
24166       {
24167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24168       };
24169     }
24170   }
24171
24172   jresult = (void *)result;
24173   return jresult;
24174 }
24175
24176
24177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
24178   void * jresult ;
24179   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24180   Dali::PixelData *arg2 = 0 ;
24181   Dali::PixelData *result = 0 ;
24182
24183   arg1 = (Dali::PixelData *)jarg1;
24184   arg2 = (Dali::PixelData *)jarg2;
24185   if (!arg2) {
24186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
24187     return 0;
24188   }
24189   {
24190     try {
24191       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
24192     } catch (std::out_of_range& e) {
24193       {
24194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24195       };
24196     } catch (std::exception& e) {
24197       {
24198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24199       };
24200     } catch (Dali::DaliException e) {
24201       {
24202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24203       };
24204     } catch (...) {
24205       {
24206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24207       };
24208     }
24209   }
24210
24211   jresult = (void *)result;
24212   return jresult;
24213 }
24214
24215
24216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
24217   unsigned int jresult ;
24218   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24219   unsigned int result;
24220
24221   arg1 = (Dali::PixelData *)jarg1;
24222   {
24223     try {
24224       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
24225     } catch (std::out_of_range& e) {
24226       {
24227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24228       };
24229     } catch (std::exception& e) {
24230       {
24231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24232       };
24233     } catch (Dali::DaliException e) {
24234       {
24235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24236       };
24237     } catch (...) {
24238       {
24239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24240       };
24241     }
24242   }
24243
24244   jresult = result;
24245   return jresult;
24246 }
24247
24248
24249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
24250   unsigned int jresult ;
24251   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24252   unsigned int result;
24253
24254   arg1 = (Dali::PixelData *)jarg1;
24255   {
24256     try {
24257       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
24258     } catch (std::out_of_range& e) {
24259       {
24260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24261       };
24262     } catch (std::exception& e) {
24263       {
24264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24265       };
24266     } catch (Dali::DaliException e) {
24267       {
24268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24269       };
24270     } catch (...) {
24271       {
24272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24273       };
24274     }
24275   }
24276
24277   jresult = result;
24278   return jresult;
24279 }
24280
24281
24282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
24283   int jresult ;
24284   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
24285   Dali::Pixel::Format result;
24286
24287   arg1 = (Dali::PixelData *)jarg1;
24288   {
24289     try {
24290       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
24291     } catch (std::out_of_range& e) {
24292       {
24293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24294       };
24295     } catch (std::exception& e) {
24296       {
24297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24298       };
24299     } catch (Dali::DaliException e) {
24300       {
24301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24302       };
24303     } catch (...) {
24304       {
24305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24306       };
24307     }
24308   }
24309
24310   jresult = (int)result;
24311   return jresult;
24312 }
24313
24314
24315 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
24316   unsigned int jresult ;
24317   unsigned int result;
24318
24319   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
24320   jresult = result;
24321   return jresult;
24322 }
24323
24324
24325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
24326   unsigned int jresult ;
24327   unsigned int result;
24328
24329   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24330   jresult = result;
24331   return jresult;
24332 }
24333
24334
24335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24336   unsigned int jresult ;
24337   unsigned int result;
24338
24339   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24340   jresult = result;
24341   return jresult;
24342 }
24343
24344
24345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24346   unsigned int jresult ;
24347   unsigned int result;
24348
24349   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24350   jresult = result;
24351   return jresult;
24352 }
24353
24354
24355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24356   unsigned int jresult ;
24357   unsigned int result;
24358
24359   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24360   jresult = result;
24361   return jresult;
24362 }
24363
24364
24365 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24366   unsigned int jresult ;
24367   unsigned int result;
24368
24369   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24370   jresult = result;
24371   return jresult;
24372 }
24373
24374
24375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24376   void * jresult ;
24377   Dali::TextureType::Type arg1 ;
24378   Dali::Pixel::Format arg2 ;
24379   unsigned int arg3 ;
24380   unsigned int arg4 ;
24381   Dali::Texture result;
24382
24383   arg1 = (Dali::TextureType::Type)jarg1;
24384   arg2 = (Dali::Pixel::Format)jarg2;
24385   arg3 = (unsigned int)jarg3;
24386   arg4 = (unsigned int)jarg4;
24387   {
24388     try {
24389       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24390     } catch (std::out_of_range& e) {
24391       {
24392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24393       };
24394     } catch (std::exception& e) {
24395       {
24396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24397       };
24398     } catch (Dali::DaliException e) {
24399       {
24400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24401       };
24402     } catch (...) {
24403       {
24404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24405       };
24406     }
24407   }
24408
24409   jresult = new Dali::Texture((const Dali::Texture &)result);
24410   return jresult;
24411 }
24412
24413
24414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24415   void * jresult ;
24416   NativeImageInterface *arg1 = 0 ;
24417   Dali::Texture result;
24418
24419   arg1 = (NativeImageInterface *)jarg1;
24420   if (!arg1) {
24421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24422     return 0;
24423   }
24424   {
24425     try {
24426       result = Dali::Texture::New(*arg1);
24427     } catch (std::out_of_range& e) {
24428       {
24429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24430       };
24431     } catch (std::exception& e) {
24432       {
24433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24434       };
24435     } catch (Dali::DaliException e) {
24436       {
24437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24438       };
24439     } catch (...) {
24440       {
24441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24442       };
24443     }
24444   }
24445
24446   jresult = new Dali::Texture((const Dali::Texture &)result);
24447   return jresult;
24448 }
24449
24450
24451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24452   void * jresult ;
24453   Dali::Texture *result = 0 ;
24454
24455   {
24456     try {
24457       result = (Dali::Texture *)new Dali::Texture();
24458     } catch (std::out_of_range& e) {
24459       {
24460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24461       };
24462     } catch (std::exception& e) {
24463       {
24464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24465       };
24466     } catch (Dali::DaliException e) {
24467       {
24468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24469       };
24470     } catch (...) {
24471       {
24472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24473       };
24474     }
24475   }
24476
24477   jresult = (void *)result;
24478   return jresult;
24479 }
24480
24481
24482 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24483   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24484
24485   arg1 = (Dali::Texture *)jarg1;
24486   {
24487     try {
24488       delete arg1;
24489     } catch (std::out_of_range& e) {
24490       {
24491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24492       };
24493     } catch (std::exception& e) {
24494       {
24495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24496       };
24497     } catch (Dali::DaliException e) {
24498       {
24499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24500       };
24501     } catch (...) {
24502       {
24503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24504       };
24505     }
24506   }
24507
24508 }
24509
24510
24511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24512   void * jresult ;
24513   Dali::Texture *arg1 = 0 ;
24514   Dali::Texture *result = 0 ;
24515
24516   arg1 = (Dali::Texture *)jarg1;
24517   if (!arg1) {
24518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24519     return 0;
24520   }
24521   {
24522     try {
24523       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24524     } catch (std::out_of_range& e) {
24525       {
24526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24527       };
24528     } catch (std::exception& e) {
24529       {
24530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24531       };
24532     } catch (Dali::DaliException e) {
24533       {
24534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24535       };
24536     } catch (...) {
24537       {
24538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24539       };
24540     }
24541   }
24542
24543   jresult = (void *)result;
24544   return jresult;
24545 }
24546
24547
24548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24549   void * jresult ;
24550   Dali::BaseHandle arg1 ;
24551   Dali::BaseHandle *argp1 ;
24552   Dali::Texture result;
24553
24554   argp1 = (Dali::BaseHandle *)jarg1;
24555   if (!argp1) {
24556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24557     return 0;
24558   }
24559   arg1 = *argp1;
24560   {
24561     try {
24562       result = Dali::Texture::DownCast(arg1);
24563     } catch (std::out_of_range& e) {
24564       {
24565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24566       };
24567     } catch (std::exception& e) {
24568       {
24569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24570       };
24571     } catch (Dali::DaliException e) {
24572       {
24573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24574       };
24575     } catch (...) {
24576       {
24577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24578       };
24579     }
24580   }
24581
24582   jresult = new Dali::Texture((const Dali::Texture &)result);
24583   return jresult;
24584 }
24585
24586
24587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24588   void * jresult ;
24589   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24590   Dali::Texture *arg2 = 0 ;
24591   Dali::Texture *result = 0 ;
24592
24593   arg1 = (Dali::Texture *)jarg1;
24594   arg2 = (Dali::Texture *)jarg2;
24595   if (!arg2) {
24596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24597     return 0;
24598   }
24599   {
24600     try {
24601       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24602     } catch (std::out_of_range& e) {
24603       {
24604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24605       };
24606     } catch (std::exception& e) {
24607       {
24608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24609       };
24610     } catch (Dali::DaliException e) {
24611       {
24612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24613       };
24614     } catch (...) {
24615       {
24616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24617       };
24618     }
24619   }
24620
24621   jresult = (void *)result;
24622   return jresult;
24623 }
24624
24625
24626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24627   unsigned int jresult ;
24628   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24629   Dali::PixelData arg2 ;
24630   Dali::PixelData *argp2 ;
24631   bool result;
24632
24633   arg1 = (Dali::Texture *)jarg1;
24634   argp2 = (Dali::PixelData *)jarg2;
24635   if (!argp2) {
24636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24637     return 0;
24638   }
24639   arg2 = *argp2;
24640   {
24641     try {
24642       result = (bool)(arg1)->Upload(arg2);
24643     } catch (std::out_of_range& e) {
24644       {
24645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24646       };
24647     } catch (std::exception& e) {
24648       {
24649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24650       };
24651     } catch (Dali::DaliException e) {
24652       {
24653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24654       };
24655     } catch (...) {
24656       {
24657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24658       };
24659     }
24660   }
24661
24662   jresult = result;
24663   return jresult;
24664 }
24665
24666
24667 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) {
24668   unsigned int jresult ;
24669   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24670   Dali::PixelData arg2 ;
24671   unsigned int arg3 ;
24672   unsigned int arg4 ;
24673   unsigned int arg5 ;
24674   unsigned int arg6 ;
24675   unsigned int arg7 ;
24676   unsigned int arg8 ;
24677   Dali::PixelData *argp2 ;
24678   bool result;
24679
24680   arg1 = (Dali::Texture *)jarg1;
24681   argp2 = (Dali::PixelData *)jarg2;
24682   if (!argp2) {
24683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24684     return 0;
24685   }
24686   arg2 = *argp2;
24687   arg3 = (unsigned int)jarg3;
24688   arg4 = (unsigned int)jarg4;
24689   arg5 = (unsigned int)jarg5;
24690   arg6 = (unsigned int)jarg6;
24691   arg7 = (unsigned int)jarg7;
24692   arg8 = (unsigned int)jarg8;
24693   {
24694     try {
24695       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24696     } catch (std::out_of_range& e) {
24697       {
24698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24699       };
24700     } catch (std::exception& e) {
24701       {
24702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24703       };
24704     } catch (Dali::DaliException e) {
24705       {
24706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24707       };
24708     } catch (...) {
24709       {
24710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24711       };
24712     }
24713   }
24714
24715   jresult = result;
24716   return jresult;
24717 }
24718
24719
24720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24721   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24722
24723   arg1 = (Dali::Texture *)jarg1;
24724   {
24725     try {
24726       (arg1)->GenerateMipmaps();
24727     } catch (std::out_of_range& e) {
24728       {
24729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24730       };
24731     } catch (std::exception& e) {
24732       {
24733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24734       };
24735     } catch (Dali::DaliException e) {
24736       {
24737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24738       };
24739     } catch (...) {
24740       {
24741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24742       };
24743     }
24744   }
24745
24746 }
24747
24748
24749 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24750   unsigned int jresult ;
24751   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24752   unsigned int result;
24753
24754   arg1 = (Dali::Texture *)jarg1;
24755   {
24756     try {
24757       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24758     } catch (std::out_of_range& e) {
24759       {
24760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24761       };
24762     } catch (std::exception& e) {
24763       {
24764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24765       };
24766     } catch (Dali::DaliException e) {
24767       {
24768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24769       };
24770     } catch (...) {
24771       {
24772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24773       };
24774     }
24775   }
24776
24777   jresult = result;
24778   return jresult;
24779 }
24780
24781
24782 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24783   unsigned int jresult ;
24784   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24785   unsigned int result;
24786
24787   arg1 = (Dali::Texture *)jarg1;
24788   {
24789     try {
24790       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24791     } catch (std::out_of_range& e) {
24792       {
24793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24794       };
24795     } catch (std::exception& e) {
24796       {
24797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24798       };
24799     } catch (Dali::DaliException e) {
24800       {
24801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24802       };
24803     } catch (...) {
24804       {
24805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24806       };
24807     }
24808   }
24809
24810   jresult = result;
24811   return jresult;
24812 }
24813
24814
24815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24816   void * jresult ;
24817   Dali::Sampler result;
24818
24819   {
24820     try {
24821       result = Dali::Sampler::New();
24822     } catch (std::out_of_range& e) {
24823       {
24824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24825       };
24826     } catch (std::exception& e) {
24827       {
24828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24829       };
24830     } catch (Dali::DaliException e) {
24831       {
24832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24833       };
24834     } catch (...) {
24835       {
24836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24837       };
24838     }
24839   }
24840
24841   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24842   return jresult;
24843 }
24844
24845
24846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24847   void * jresult ;
24848   Dali::Sampler *result = 0 ;
24849
24850   {
24851     try {
24852       result = (Dali::Sampler *)new Dali::Sampler();
24853     } catch (std::out_of_range& e) {
24854       {
24855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24856       };
24857     } catch (std::exception& e) {
24858       {
24859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24860       };
24861     } catch (Dali::DaliException e) {
24862       {
24863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24864       };
24865     } catch (...) {
24866       {
24867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24868       };
24869     }
24870   }
24871
24872   jresult = (void *)result;
24873   return jresult;
24874 }
24875
24876
24877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24878   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24879
24880   arg1 = (Dali::Sampler *)jarg1;
24881   {
24882     try {
24883       delete arg1;
24884     } catch (std::out_of_range& e) {
24885       {
24886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24887       };
24888     } catch (std::exception& e) {
24889       {
24890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24891       };
24892     } catch (Dali::DaliException e) {
24893       {
24894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24895       };
24896     } catch (...) {
24897       {
24898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24899       };
24900     }
24901   }
24902
24903 }
24904
24905
24906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24907   void * jresult ;
24908   Dali::Sampler *arg1 = 0 ;
24909   Dali::Sampler *result = 0 ;
24910
24911   arg1 = (Dali::Sampler *)jarg1;
24912   if (!arg1) {
24913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24914     return 0;
24915   }
24916   {
24917     try {
24918       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24919     } catch (std::out_of_range& e) {
24920       {
24921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24922       };
24923     } catch (std::exception& e) {
24924       {
24925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24926       };
24927     } catch (Dali::DaliException e) {
24928       {
24929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24930       };
24931     } catch (...) {
24932       {
24933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24934       };
24935     }
24936   }
24937
24938   jresult = (void *)result;
24939   return jresult;
24940 }
24941
24942
24943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24944   void * jresult ;
24945   Dali::BaseHandle arg1 ;
24946   Dali::BaseHandle *argp1 ;
24947   Dali::Sampler result;
24948
24949   argp1 = (Dali::BaseHandle *)jarg1;
24950   if (!argp1) {
24951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24952     return 0;
24953   }
24954   arg1 = *argp1;
24955   {
24956     try {
24957       result = Dali::Sampler::DownCast(arg1);
24958     } catch (std::out_of_range& e) {
24959       {
24960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24961       };
24962     } catch (std::exception& e) {
24963       {
24964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24965       };
24966     } catch (Dali::DaliException e) {
24967       {
24968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24969       };
24970     } catch (...) {
24971       {
24972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24973       };
24974     }
24975   }
24976
24977   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24978   return jresult;
24979 }
24980
24981
24982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24983   void * jresult ;
24984   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24985   Dali::Sampler *arg2 = 0 ;
24986   Dali::Sampler *result = 0 ;
24987
24988   arg1 = (Dali::Sampler *)jarg1;
24989   arg2 = (Dali::Sampler *)jarg2;
24990   if (!arg2) {
24991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24992     return 0;
24993   }
24994   {
24995     try {
24996       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24997     } catch (std::out_of_range& e) {
24998       {
24999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25000       };
25001     } catch (std::exception& e) {
25002       {
25003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25004       };
25005     } catch (Dali::DaliException e) {
25006       {
25007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25008       };
25009     } catch (...) {
25010       {
25011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25012       };
25013     }
25014   }
25015
25016   jresult = (void *)result;
25017   return jresult;
25018 }
25019
25020
25021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
25022   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25023   Dali::FilterMode::Type arg2 ;
25024   Dali::FilterMode::Type arg3 ;
25025
25026   arg1 = (Dali::Sampler *)jarg1;
25027   arg2 = (Dali::FilterMode::Type)jarg2;
25028   arg3 = (Dali::FilterMode::Type)jarg3;
25029   {
25030     try {
25031       (arg1)->SetFilterMode(arg2,arg3);
25032     } catch (std::out_of_range& e) {
25033       {
25034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25035       };
25036     } catch (std::exception& e) {
25037       {
25038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25039       };
25040     } catch (Dali::DaliException e) {
25041       {
25042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25043       };
25044     } catch (...) {
25045       {
25046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25047       };
25048     }
25049   }
25050
25051 }
25052
25053
25054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
25055   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25056   Dali::WrapMode::Type arg2 ;
25057   Dali::WrapMode::Type arg3 ;
25058
25059   arg1 = (Dali::Sampler *)jarg1;
25060   arg2 = (Dali::WrapMode::Type)jarg2;
25061   arg3 = (Dali::WrapMode::Type)jarg3;
25062   {
25063     try {
25064       (arg1)->SetWrapMode(arg2,arg3);
25065     } catch (std::out_of_range& e) {
25066       {
25067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25068       };
25069     } catch (std::exception& e) {
25070       {
25071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25072       };
25073     } catch (Dali::DaliException e) {
25074       {
25075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25076       };
25077     } catch (...) {
25078       {
25079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25080       };
25081     }
25082   }
25083
25084 }
25085
25086
25087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
25088   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
25089   Dali::WrapMode::Type arg2 ;
25090   Dali::WrapMode::Type arg3 ;
25091   Dali::WrapMode::Type arg4 ;
25092
25093   arg1 = (Dali::Sampler *)jarg1;
25094   arg2 = (Dali::WrapMode::Type)jarg2;
25095   arg3 = (Dali::WrapMode::Type)jarg3;
25096   arg4 = (Dali::WrapMode::Type)jarg4;
25097   {
25098     try {
25099       (arg1)->SetWrapMode(arg2,arg3,arg4);
25100     } catch (std::out_of_range& e) {
25101       {
25102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25103       };
25104     } catch (std::exception& e) {
25105       {
25106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25107       };
25108     } catch (Dali::DaliException e) {
25109       {
25110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25111       };
25112     } catch (...) {
25113       {
25114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25115       };
25116     }
25117   }
25118
25119 }
25120
25121
25122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
25123   void * jresult ;
25124   Dali::TextureSet result;
25125
25126   {
25127     try {
25128       result = Dali::TextureSet::New();
25129     } catch (std::out_of_range& e) {
25130       {
25131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25132       };
25133     } catch (std::exception& e) {
25134       {
25135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25136       };
25137     } catch (Dali::DaliException e) {
25138       {
25139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25140       };
25141     } catch (...) {
25142       {
25143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25144       };
25145     }
25146   }
25147
25148   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25149   return jresult;
25150 }
25151
25152
25153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
25154   void * jresult ;
25155   Dali::TextureSet *result = 0 ;
25156
25157   {
25158     try {
25159       result = (Dali::TextureSet *)new Dali::TextureSet();
25160     } catch (std::out_of_range& e) {
25161       {
25162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25163       };
25164     } catch (std::exception& e) {
25165       {
25166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25167       };
25168     } catch (Dali::DaliException e) {
25169       {
25170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25171       };
25172     } catch (...) {
25173       {
25174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25175       };
25176     }
25177   }
25178
25179   jresult = (void *)result;
25180   return jresult;
25181 }
25182
25183
25184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
25185   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25186
25187   arg1 = (Dali::TextureSet *)jarg1;
25188   {
25189     try {
25190       delete arg1;
25191     } catch (std::out_of_range& e) {
25192       {
25193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25194       };
25195     } catch (std::exception& e) {
25196       {
25197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25198       };
25199     } catch (Dali::DaliException e) {
25200       {
25201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25202       };
25203     } catch (...) {
25204       {
25205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25206       };
25207     }
25208   }
25209
25210 }
25211
25212
25213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
25214   void * jresult ;
25215   Dali::TextureSet *arg1 = 0 ;
25216   Dali::TextureSet *result = 0 ;
25217
25218   arg1 = (Dali::TextureSet *)jarg1;
25219   if (!arg1) {
25220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25221     return 0;
25222   }
25223   {
25224     try {
25225       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
25226     } catch (std::out_of_range& e) {
25227       {
25228         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25229       };
25230     } catch (std::exception& e) {
25231       {
25232         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25233       };
25234     } catch (Dali::DaliException e) {
25235       {
25236         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25237       };
25238     } catch (...) {
25239       {
25240         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25241       };
25242     }
25243   }
25244
25245   jresult = (void *)result;
25246   return jresult;
25247 }
25248
25249
25250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
25251   void * jresult ;
25252   Dali::BaseHandle arg1 ;
25253   Dali::BaseHandle *argp1 ;
25254   Dali::TextureSet result;
25255
25256   argp1 = (Dali::BaseHandle *)jarg1;
25257   if (!argp1) {
25258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25259     return 0;
25260   }
25261   arg1 = *argp1;
25262   {
25263     try {
25264       result = Dali::TextureSet::DownCast(arg1);
25265     } catch (std::out_of_range& e) {
25266       {
25267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25268       };
25269     } catch (std::exception& e) {
25270       {
25271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25272       };
25273     } catch (Dali::DaliException e) {
25274       {
25275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25276       };
25277     } catch (...) {
25278       {
25279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25280       };
25281     }
25282   }
25283
25284   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
25285   return jresult;
25286 }
25287
25288
25289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
25290   void * jresult ;
25291   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25292   Dali::TextureSet *arg2 = 0 ;
25293   Dali::TextureSet *result = 0 ;
25294
25295   arg1 = (Dali::TextureSet *)jarg1;
25296   arg2 = (Dali::TextureSet *)jarg2;
25297   if (!arg2) {
25298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
25299     return 0;
25300   }
25301   {
25302     try {
25303       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
25304     } catch (std::out_of_range& e) {
25305       {
25306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25307       };
25308     } catch (std::exception& e) {
25309       {
25310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25311       };
25312     } catch (Dali::DaliException e) {
25313       {
25314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25315       };
25316     } catch (...) {
25317       {
25318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25319       };
25320     }
25321   }
25322
25323   jresult = (void *)result;
25324   return jresult;
25325 }
25326
25327
25328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25329   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25330   size_t arg2 ;
25331   Dali::Texture arg3 ;
25332   Dali::Texture *argp3 ;
25333
25334   arg1 = (Dali::TextureSet *)jarg1;
25335   arg2 = (size_t)jarg2;
25336   argp3 = (Dali::Texture *)jarg3;
25337   if (!argp3) {
25338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25339     return ;
25340   }
25341   arg3 = *argp3;
25342   {
25343     try {
25344       (arg1)->SetTexture(arg2,arg3);
25345     } catch (std::out_of_range& e) {
25346       {
25347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25348       };
25349     } catch (std::exception& e) {
25350       {
25351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25352       };
25353     } catch (Dali::DaliException e) {
25354       {
25355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25356       };
25357     } catch (...) {
25358       {
25359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25360       };
25361     }
25362   }
25363
25364 }
25365
25366
25367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25368   void * jresult ;
25369   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25370   size_t arg2 ;
25371   Dali::Texture result;
25372
25373   arg1 = (Dali::TextureSet *)jarg1;
25374   arg2 = (size_t)jarg2;
25375   {
25376     try {
25377       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25378     } catch (std::out_of_range& e) {
25379       {
25380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25381       };
25382     } catch (std::exception& e) {
25383       {
25384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25385       };
25386     } catch (Dali::DaliException e) {
25387       {
25388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25389       };
25390     } catch (...) {
25391       {
25392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25393       };
25394     }
25395   }
25396
25397   jresult = new Dali::Texture((const Dali::Texture &)result);
25398   return jresult;
25399 }
25400
25401
25402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25403   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25404   size_t arg2 ;
25405   Dali::Sampler arg3 ;
25406   Dali::Sampler *argp3 ;
25407
25408   arg1 = (Dali::TextureSet *)jarg1;
25409   arg2 = (size_t)jarg2;
25410   argp3 = (Dali::Sampler *)jarg3;
25411   if (!argp3) {
25412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25413     return ;
25414   }
25415   arg3 = *argp3;
25416   {
25417     try {
25418       (arg1)->SetSampler(arg2,arg3);
25419     } catch (std::out_of_range& e) {
25420       {
25421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25422       };
25423     } catch (std::exception& e) {
25424       {
25425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25426       };
25427     } catch (Dali::DaliException e) {
25428       {
25429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25430       };
25431     } catch (...) {
25432       {
25433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25434       };
25435     }
25436   }
25437
25438 }
25439
25440
25441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25442   void * jresult ;
25443   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25444   size_t arg2 ;
25445   Dali::Sampler result;
25446
25447   arg1 = (Dali::TextureSet *)jarg1;
25448   arg2 = (size_t)jarg2;
25449   {
25450     try {
25451       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
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 (Dali::DaliException e) {
25461       {
25462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25463       };
25464     } catch (...) {
25465       {
25466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25467       };
25468     }
25469   }
25470
25471   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25472   return jresult;
25473 }
25474
25475
25476 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25477   unsigned long jresult ;
25478   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25479   size_t result;
25480
25481   arg1 = (Dali::TextureSet *)jarg1;
25482   {
25483     try {
25484       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25485     } catch (std::out_of_range& e) {
25486       {
25487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25488       };
25489     } catch (std::exception& e) {
25490       {
25491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25492       };
25493     } catch (Dali::DaliException e) {
25494       {
25495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25496       };
25497     } catch (...) {
25498       {
25499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25500       };
25501     }
25502   }
25503
25504   jresult = (unsigned long)result;
25505   return jresult;
25506 }
25507
25508
25509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25510   void * jresult ;
25511   Dali::Property::Map *arg1 = 0 ;
25512   Dali::PropertyBuffer result;
25513
25514   arg1 = (Dali::Property::Map *)jarg1;
25515   if (!arg1) {
25516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25517     return 0;
25518   }
25519   {
25520     try {
25521       result = Dali::PropertyBuffer::New(*arg1);
25522     } catch (std::out_of_range& e) {
25523       {
25524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25525       };
25526     } catch (std::exception& e) {
25527       {
25528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25529       };
25530     } catch (Dali::DaliException e) {
25531       {
25532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25533       };
25534     } catch (...) {
25535       {
25536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25537       };
25538     }
25539   }
25540
25541   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25542   return jresult;
25543 }
25544
25545
25546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25547   void * jresult ;
25548   Dali::PropertyBuffer *result = 0 ;
25549
25550   {
25551     try {
25552       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25553     } catch (std::out_of_range& e) {
25554       {
25555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25556       };
25557     } catch (std::exception& e) {
25558       {
25559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25560       };
25561     } catch (Dali::DaliException e) {
25562       {
25563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25564       };
25565     } catch (...) {
25566       {
25567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25568       };
25569     }
25570   }
25571
25572   jresult = (void *)result;
25573   return jresult;
25574 }
25575
25576
25577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25578   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25579
25580   arg1 = (Dali::PropertyBuffer *)jarg1;
25581   {
25582     try {
25583       delete arg1;
25584     } catch (std::out_of_range& e) {
25585       {
25586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25587       };
25588     } catch (std::exception& e) {
25589       {
25590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25591       };
25592     } catch (Dali::DaliException e) {
25593       {
25594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25595       };
25596     } catch (...) {
25597       {
25598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25599       };
25600     }
25601   }
25602
25603 }
25604
25605
25606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25607   void * jresult ;
25608   Dali::PropertyBuffer *arg1 = 0 ;
25609   Dali::PropertyBuffer *result = 0 ;
25610
25611   arg1 = (Dali::PropertyBuffer *)jarg1;
25612   if (!arg1) {
25613     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25614     return 0;
25615   }
25616   {
25617     try {
25618       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25619     } catch (std::out_of_range& e) {
25620       {
25621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25622       };
25623     } catch (std::exception& e) {
25624       {
25625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25626       };
25627     } catch (Dali::DaliException e) {
25628       {
25629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25630       };
25631     } catch (...) {
25632       {
25633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25634       };
25635     }
25636   }
25637
25638   jresult = (void *)result;
25639   return jresult;
25640 }
25641
25642
25643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25644   void * jresult ;
25645   Dali::BaseHandle arg1 ;
25646   Dali::BaseHandle *argp1 ;
25647   Dali::PropertyBuffer result;
25648
25649   argp1 = (Dali::BaseHandle *)jarg1;
25650   if (!argp1) {
25651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25652     return 0;
25653   }
25654   arg1 = *argp1;
25655   {
25656     try {
25657       result = Dali::PropertyBuffer::DownCast(arg1);
25658     } catch (std::out_of_range& e) {
25659       {
25660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25661       };
25662     } catch (std::exception& e) {
25663       {
25664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25665       };
25666     } catch (Dali::DaliException e) {
25667       {
25668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25669       };
25670     } catch (...) {
25671       {
25672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25673       };
25674     }
25675   }
25676
25677   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25678   return jresult;
25679 }
25680
25681
25682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25683   void * jresult ;
25684   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25685   Dali::PropertyBuffer *arg2 = 0 ;
25686   Dali::PropertyBuffer *result = 0 ;
25687
25688   arg1 = (Dali::PropertyBuffer *)jarg1;
25689   arg2 = (Dali::PropertyBuffer *)jarg2;
25690   if (!arg2) {
25691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25692     return 0;
25693   }
25694   {
25695     try {
25696       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25697     } catch (std::out_of_range& e) {
25698       {
25699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25700       };
25701     } catch (std::exception& e) {
25702       {
25703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25704       };
25705     } catch (Dali::DaliException e) {
25706       {
25707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25708       };
25709     } catch (...) {
25710       {
25711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25712       };
25713     }
25714   }
25715
25716   jresult = (void *)result;
25717   return jresult;
25718 }
25719
25720
25721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25722   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25723   void *arg2 = (void *) 0 ;
25724   std::size_t arg3 ;
25725
25726   arg1 = (Dali::PropertyBuffer *)jarg1;
25727   arg2 = jarg2;
25728   arg3 = (std::size_t)jarg3;
25729   {
25730     try {
25731       (arg1)->SetData((void const *)arg2,arg3);
25732     } catch (std::out_of_range& e) {
25733       {
25734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25735       };
25736     } catch (std::exception& e) {
25737       {
25738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25739       };
25740     } catch (Dali::DaliException e) {
25741       {
25742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25743       };
25744     } catch (...) {
25745       {
25746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25747       };
25748     }
25749   }
25750
25751 }
25752
25753
25754 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25755   unsigned long jresult ;
25756   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25757   std::size_t result;
25758
25759   arg1 = (Dali::PropertyBuffer *)jarg1;
25760   {
25761     try {
25762       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25763     } catch (std::out_of_range& e) {
25764       {
25765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25766       };
25767     } catch (std::exception& e) {
25768       {
25769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25770       };
25771     } catch (Dali::DaliException e) {
25772       {
25773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25774       };
25775     } catch (...) {
25776       {
25777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25778       };
25779     }
25780   }
25781
25782   jresult = (unsigned long)result;
25783   return jresult;
25784 }
25785
25786
25787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25788   void * jresult ;
25789   Dali::Geometry result;
25790
25791   {
25792     try {
25793       result = Dali::Geometry::New();
25794     } catch (std::out_of_range& e) {
25795       {
25796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25797       };
25798     } catch (std::exception& e) {
25799       {
25800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25801       };
25802     } catch (Dali::DaliException e) {
25803       {
25804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25805       };
25806     } catch (...) {
25807       {
25808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25809       };
25810     }
25811   }
25812
25813   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25814   return jresult;
25815 }
25816
25817
25818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25819   void * jresult ;
25820   Dali::Geometry *result = 0 ;
25821
25822   {
25823     try {
25824       result = (Dali::Geometry *)new Dali::Geometry();
25825     } catch (std::out_of_range& e) {
25826       {
25827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25828       };
25829     } catch (std::exception& e) {
25830       {
25831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25832       };
25833     } catch (Dali::DaliException e) {
25834       {
25835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25836       };
25837     } catch (...) {
25838       {
25839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25840       };
25841     }
25842   }
25843
25844   jresult = (void *)result;
25845   return jresult;
25846 }
25847
25848
25849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25850   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25851
25852   arg1 = (Dali::Geometry *)jarg1;
25853   {
25854     try {
25855       delete arg1;
25856     } catch (std::out_of_range& e) {
25857       {
25858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25859       };
25860     } catch (std::exception& e) {
25861       {
25862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25863       };
25864     } catch (Dali::DaliException e) {
25865       {
25866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25867       };
25868     } catch (...) {
25869       {
25870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25871       };
25872     }
25873   }
25874
25875 }
25876
25877
25878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25879   void * jresult ;
25880   Dali::Geometry *arg1 = 0 ;
25881   Dali::Geometry *result = 0 ;
25882
25883   arg1 = (Dali::Geometry *)jarg1;
25884   if (!arg1) {
25885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25886     return 0;
25887   }
25888   {
25889     try {
25890       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25891     } catch (std::out_of_range& e) {
25892       {
25893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25894       };
25895     } catch (std::exception& e) {
25896       {
25897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25898       };
25899     } catch (Dali::DaliException e) {
25900       {
25901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25902       };
25903     } catch (...) {
25904       {
25905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25906       };
25907     }
25908   }
25909
25910   jresult = (void *)result;
25911   return jresult;
25912 }
25913
25914
25915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25916   void * jresult ;
25917   Dali::BaseHandle arg1 ;
25918   Dali::BaseHandle *argp1 ;
25919   Dali::Geometry result;
25920
25921   argp1 = (Dali::BaseHandle *)jarg1;
25922   if (!argp1) {
25923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25924     return 0;
25925   }
25926   arg1 = *argp1;
25927   {
25928     try {
25929       result = Dali::Geometry::DownCast(arg1);
25930     } catch (std::out_of_range& e) {
25931       {
25932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25933       };
25934     } catch (std::exception& e) {
25935       {
25936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25937       };
25938     } catch (Dali::DaliException e) {
25939       {
25940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25941       };
25942     } catch (...) {
25943       {
25944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25945       };
25946     }
25947   }
25948
25949   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25950   return jresult;
25951 }
25952
25953
25954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25955   void * jresult ;
25956   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25957   Dali::Geometry *arg2 = 0 ;
25958   Dali::Geometry *result = 0 ;
25959
25960   arg1 = (Dali::Geometry *)jarg1;
25961   arg2 = (Dali::Geometry *)jarg2;
25962   if (!arg2) {
25963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25964     return 0;
25965   }
25966   {
25967     try {
25968       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25969     } catch (std::out_of_range& e) {
25970       {
25971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25972       };
25973     } catch (std::exception& e) {
25974       {
25975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25976       };
25977     } catch (Dali::DaliException e) {
25978       {
25979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25980       };
25981     } catch (...) {
25982       {
25983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25984       };
25985     }
25986   }
25987
25988   jresult = (void *)result;
25989   return jresult;
25990 }
25991
25992
25993 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25994   unsigned long jresult ;
25995   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25996   Dali::PropertyBuffer *arg2 = 0 ;
25997   std::size_t result;
25998
25999   arg1 = (Dali::Geometry *)jarg1;
26000   arg2 = (Dali::PropertyBuffer *)jarg2;
26001   if (!arg2) {
26002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
26003     return 0;
26004   }
26005   {
26006     try {
26007       result = (arg1)->AddVertexBuffer(*arg2);
26008     } catch (std::out_of_range& e) {
26009       {
26010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26011       };
26012     } catch (std::exception& e) {
26013       {
26014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26015       };
26016     } catch (Dali::DaliException e) {
26017       {
26018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26019       };
26020     } catch (...) {
26021       {
26022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26023       };
26024     }
26025   }
26026
26027   jresult = (unsigned long)result;
26028   return jresult;
26029 }
26030
26031
26032 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
26033   unsigned long jresult ;
26034   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26035   std::size_t result;
26036
26037   arg1 = (Dali::Geometry *)jarg1;
26038   {
26039     try {
26040       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
26041     } catch (std::out_of_range& e) {
26042       {
26043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26044       };
26045     } catch (std::exception& e) {
26046       {
26047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26048       };
26049     } catch (Dali::DaliException e) {
26050       {
26051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26052       };
26053     } catch (...) {
26054       {
26055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26056       };
26057     }
26058   }
26059
26060   jresult = (unsigned long)result;
26061   return jresult;
26062 }
26063
26064
26065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
26066   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26067   std::size_t arg2 ;
26068
26069   arg1 = (Dali::Geometry *)jarg1;
26070   arg2 = (std::size_t)jarg2;
26071   {
26072     try {
26073       (arg1)->RemoveVertexBuffer(arg2);
26074     } catch (std::out_of_range& e) {
26075       {
26076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26077       };
26078     } catch (std::exception& e) {
26079       {
26080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26081       };
26082     } catch (Dali::DaliException e) {
26083       {
26084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26085       };
26086     } catch (...) {
26087       {
26088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26089       };
26090     }
26091   }
26092
26093 }
26094
26095
26096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
26097   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26098   unsigned short *arg2 = (unsigned short *) 0 ;
26099   size_t arg3 ;
26100
26101   arg1 = (Dali::Geometry *)jarg1;
26102   arg2 = jarg2;
26103   arg3 = (size_t)jarg3;
26104   {
26105     try {
26106       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
26107     } catch (std::out_of_range& e) {
26108       {
26109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26110       };
26111     } catch (std::exception& e) {
26112       {
26113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26114       };
26115     } catch (Dali::DaliException e) {
26116       {
26117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26118       };
26119     } catch (...) {
26120       {
26121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26122       };
26123     }
26124   }
26125
26126
26127
26128 }
26129
26130
26131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
26132   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26133   Dali::Geometry::Type arg2 ;
26134
26135   arg1 = (Dali::Geometry *)jarg1;
26136   arg2 = (Dali::Geometry::Type)jarg2;
26137   {
26138     try {
26139       (arg1)->SetType(arg2);
26140     } catch (std::out_of_range& e) {
26141       {
26142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26143       };
26144     } catch (std::exception& e) {
26145       {
26146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26147       };
26148     } catch (Dali::DaliException e) {
26149       {
26150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26151       };
26152     } catch (...) {
26153       {
26154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26155       };
26156     }
26157   }
26158
26159 }
26160
26161
26162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
26163   int jresult ;
26164   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
26165   Dali::Geometry::Type result;
26166
26167   arg1 = (Dali::Geometry *)jarg1;
26168   {
26169     try {
26170       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
26171     } catch (std::out_of_range& e) {
26172       {
26173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26174       };
26175     } catch (std::exception& e) {
26176       {
26177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26178       };
26179     } catch (Dali::DaliException e) {
26180       {
26181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26182       };
26183     } catch (...) {
26184       {
26185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26186       };
26187     }
26188   }
26189
26190   jresult = (int)result;
26191   return jresult;
26192 }
26193
26194
26195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
26196   void * jresult ;
26197   Dali::Shader::Hint *result = 0 ;
26198
26199   {
26200     try {
26201       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
26202     } catch (std::out_of_range& e) {
26203       {
26204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26205       };
26206     } catch (std::exception& e) {
26207       {
26208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26209       };
26210     } catch (Dali::DaliException e) {
26211       {
26212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26213       };
26214     } catch (...) {
26215       {
26216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26217       };
26218     }
26219   }
26220
26221   jresult = (void *)result;
26222   return jresult;
26223 }
26224
26225
26226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
26227   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
26228
26229   arg1 = (Dali::Shader::Hint *)jarg1;
26230   {
26231     try {
26232       delete arg1;
26233     } catch (std::out_of_range& e) {
26234       {
26235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26236       };
26237     } catch (std::exception& e) {
26238       {
26239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26240       };
26241     } catch (Dali::DaliException e) {
26242       {
26243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26244       };
26245     } catch (...) {
26246       {
26247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26248       };
26249     }
26250   }
26251
26252 }
26253
26254
26255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
26256   int jresult ;
26257   int result;
26258
26259   result = (int)Dali::Shader::Property::PROGRAM;
26260   jresult = (int)result;
26261   return jresult;
26262 }
26263
26264
26265 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
26266   void * jresult ;
26267   Dali::Shader::Property *result = 0 ;
26268
26269   {
26270     try {
26271       result = (Dali::Shader::Property *)new Dali::Shader::Property();
26272     } catch (std::out_of_range& e) {
26273       {
26274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26275       };
26276     } catch (std::exception& e) {
26277       {
26278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26279       };
26280     } catch (Dali::DaliException e) {
26281       {
26282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26283       };
26284     } catch (...) {
26285       {
26286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26287       };
26288     }
26289   }
26290
26291   jresult = (void *)result;
26292   return jresult;
26293 }
26294
26295
26296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
26297   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
26298
26299   arg1 = (Dali::Shader::Property *)jarg1;
26300   {
26301     try {
26302       delete arg1;
26303     } catch (std::out_of_range& e) {
26304       {
26305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26306       };
26307     } catch (std::exception& e) {
26308       {
26309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26310       };
26311     } catch (Dali::DaliException e) {
26312       {
26313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26314       };
26315     } catch (...) {
26316       {
26317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26318       };
26319     }
26320   }
26321
26322 }
26323
26324
26325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
26326   void * jresult ;
26327   std::string *arg1 = 0 ;
26328   std::string *arg2 = 0 ;
26329   Dali::Shader::Hint::Value arg3 ;
26330   Dali::Shader result;
26331
26332   if (!jarg1) {
26333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26334     return 0;
26335   }
26336   std::string arg1_str(jarg1);
26337   arg1 = &arg1_str;
26338   if (!jarg2) {
26339     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26340     return 0;
26341   }
26342   std::string arg2_str(jarg2);
26343   arg2 = &arg2_str;
26344   arg3 = (Dali::Shader::Hint::Value)jarg3;
26345   {
26346     try {
26347       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26348     } catch (std::out_of_range& e) {
26349       {
26350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26351       };
26352     } catch (std::exception& e) {
26353       {
26354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26355       };
26356     } catch (Dali::DaliException e) {
26357       {
26358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26359       };
26360     } catch (...) {
26361       {
26362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26363       };
26364     }
26365   }
26366
26367   jresult = new Dali::Shader((const Dali::Shader &)result);
26368
26369   //argout typemap for const std::string&
26370
26371
26372   //argout typemap for const std::string&
26373
26374   return jresult;
26375 }
26376
26377
26378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26379   void * jresult ;
26380   std::string *arg1 = 0 ;
26381   std::string *arg2 = 0 ;
26382   Dali::Shader result;
26383
26384   if (!jarg1) {
26385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26386     return 0;
26387   }
26388   std::string arg1_str(jarg1);
26389   arg1 = &arg1_str;
26390   if (!jarg2) {
26391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26392     return 0;
26393   }
26394   std::string arg2_str(jarg2);
26395   arg2 = &arg2_str;
26396   {
26397     try {
26398       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26399     } catch (std::out_of_range& e) {
26400       {
26401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26402       };
26403     } catch (std::exception& e) {
26404       {
26405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26406       };
26407     } catch (Dali::DaliException e) {
26408       {
26409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26410       };
26411     } catch (...) {
26412       {
26413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26414       };
26415     }
26416   }
26417
26418   jresult = new Dali::Shader((const Dali::Shader &)result);
26419
26420   //argout typemap for const std::string&
26421
26422
26423   //argout typemap for const std::string&
26424
26425   return jresult;
26426 }
26427
26428
26429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26430   void * jresult ;
26431   Dali::Shader *result = 0 ;
26432
26433   {
26434     try {
26435       result = (Dali::Shader *)new Dali::Shader();
26436     } catch (std::out_of_range& e) {
26437       {
26438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26439       };
26440     } catch (std::exception& e) {
26441       {
26442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26443       };
26444     } catch (Dali::DaliException e) {
26445       {
26446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26447       };
26448     } catch (...) {
26449       {
26450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26451       };
26452     }
26453   }
26454
26455   jresult = (void *)result;
26456   return jresult;
26457 }
26458
26459
26460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26461   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26462
26463   arg1 = (Dali::Shader *)jarg1;
26464   {
26465     try {
26466       delete arg1;
26467     } catch (std::out_of_range& e) {
26468       {
26469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26470       };
26471     } catch (std::exception& e) {
26472       {
26473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26474       };
26475     } catch (Dali::DaliException e) {
26476       {
26477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26478       };
26479     } catch (...) {
26480       {
26481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26482       };
26483     }
26484   }
26485
26486 }
26487
26488
26489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26490   void * jresult ;
26491   Dali::Shader *arg1 = 0 ;
26492   Dali::Shader *result = 0 ;
26493
26494   arg1 = (Dali::Shader *)jarg1;
26495   if (!arg1) {
26496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26497     return 0;
26498   }
26499   {
26500     try {
26501       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26502     } catch (std::out_of_range& e) {
26503       {
26504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26505       };
26506     } catch (std::exception& e) {
26507       {
26508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26509       };
26510     } catch (Dali::DaliException e) {
26511       {
26512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26513       };
26514     } catch (...) {
26515       {
26516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26517       };
26518     }
26519   }
26520
26521   jresult = (void *)result;
26522   return jresult;
26523 }
26524
26525
26526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26527   void * jresult ;
26528   Dali::BaseHandle arg1 ;
26529   Dali::BaseHandle *argp1 ;
26530   Dali::Shader result;
26531
26532   argp1 = (Dali::BaseHandle *)jarg1;
26533   if (!argp1) {
26534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26535     return 0;
26536   }
26537   arg1 = *argp1;
26538   {
26539     try {
26540       result = Dali::Shader::DownCast(arg1);
26541     } catch (std::out_of_range& e) {
26542       {
26543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26544       };
26545     } catch (std::exception& e) {
26546       {
26547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26548       };
26549     } catch (Dali::DaliException e) {
26550       {
26551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26552       };
26553     } catch (...) {
26554       {
26555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26556       };
26557     }
26558   }
26559
26560   jresult = new Dali::Shader((const Dali::Shader &)result);
26561   return jresult;
26562 }
26563
26564
26565 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26566   void * jresult ;
26567   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26568   Dali::Shader *arg2 = 0 ;
26569   Dali::Shader *result = 0 ;
26570
26571   arg1 = (Dali::Shader *)jarg1;
26572   arg2 = (Dali::Shader *)jarg2;
26573   if (!arg2) {
26574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26575     return 0;
26576   }
26577   {
26578     try {
26579       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26580     } catch (std::out_of_range& e) {
26581       {
26582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26583       };
26584     } catch (std::exception& e) {
26585       {
26586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26587       };
26588     } catch (Dali::DaliException e) {
26589       {
26590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26591       };
26592     } catch (...) {
26593       {
26594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26595       };
26596     }
26597   }
26598
26599   jresult = (void *)result;
26600   return jresult;
26601 }
26602
26603
26604 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26605   int jresult ;
26606   int result;
26607
26608   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26609   jresult = (int)result;
26610   return jresult;
26611 }
26612
26613
26614 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26615   int jresult ;
26616   int result;
26617
26618   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26619   jresult = (int)result;
26620   return jresult;
26621 }
26622
26623
26624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26625   int jresult ;
26626   int result;
26627
26628   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26629   jresult = (int)result;
26630   return jresult;
26631 }
26632
26633
26634 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26635   int jresult ;
26636   int result;
26637
26638   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26639   jresult = (int)result;
26640   return jresult;
26641 }
26642
26643
26644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26645   int jresult ;
26646   int result;
26647
26648   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26649   jresult = (int)result;
26650   return jresult;
26651 }
26652
26653
26654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26655   int jresult ;
26656   int result;
26657
26658   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26659   jresult = (int)result;
26660   return jresult;
26661 }
26662
26663
26664 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26665   int jresult ;
26666   int result;
26667
26668   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26669   jresult = (int)result;
26670   return jresult;
26671 }
26672
26673
26674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26675   int jresult ;
26676   int result;
26677
26678   result = (int)Dali::Renderer::Property::BLEND_MODE;
26679   jresult = (int)result;
26680   return jresult;
26681 }
26682
26683
26684 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26685   int jresult ;
26686   int result;
26687
26688   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26689   jresult = (int)result;
26690   return jresult;
26691 }
26692
26693
26694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26695   int jresult ;
26696   int result;
26697
26698   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26699   jresult = (int)result;
26700   return jresult;
26701 }
26702
26703
26704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26705   int jresult ;
26706   int result;
26707
26708   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26709   jresult = (int)result;
26710   return jresult;
26711 }
26712
26713
26714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26715   int jresult ;
26716   int result;
26717
26718   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26719   jresult = (int)result;
26720   return jresult;
26721 }
26722
26723
26724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26725   int jresult ;
26726   int result;
26727
26728   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26729   jresult = (int)result;
26730   return jresult;
26731 }
26732
26733
26734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26735   int jresult ;
26736   int result;
26737
26738   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26739   jresult = (int)result;
26740   return jresult;
26741 }
26742
26743
26744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26745   int jresult ;
26746   int result;
26747
26748   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26749   jresult = (int)result;
26750   return jresult;
26751 }
26752
26753
26754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26755   int jresult ;
26756   int result;
26757
26758   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26759   jresult = (int)result;
26760   return jresult;
26761 }
26762
26763
26764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26765   int jresult ;
26766   int result;
26767
26768   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26769   jresult = (int)result;
26770   return jresult;
26771 }
26772
26773
26774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26775   int jresult ;
26776   int result;
26777
26778   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26779   jresult = (int)result;
26780   return jresult;
26781 }
26782
26783
26784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26785   int jresult ;
26786   int result;
26787
26788   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26789   jresult = (int)result;
26790   return jresult;
26791 }
26792
26793
26794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26795   int jresult ;
26796   int result;
26797
26798   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26799   jresult = (int)result;
26800   return jresult;
26801 }
26802
26803
26804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26805   int jresult ;
26806   int result;
26807
26808   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26809   jresult = (int)result;
26810   return jresult;
26811 }
26812
26813
26814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26815   int jresult ;
26816   int result;
26817
26818   result = (int)Dali::Renderer::Property::RENDER_MODE;
26819   jresult = (int)result;
26820   return jresult;
26821 }
26822
26823
26824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26825   int jresult ;
26826   int result;
26827
26828   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26829   jresult = (int)result;
26830   return jresult;
26831 }
26832
26833
26834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26835   int jresult ;
26836   int result;
26837
26838   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26839   jresult = (int)result;
26840   return jresult;
26841 }
26842
26843
26844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26845   int jresult ;
26846   int result;
26847
26848   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26849   jresult = (int)result;
26850   return jresult;
26851 }
26852
26853
26854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26855   int jresult ;
26856   int result;
26857
26858   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26859   jresult = (int)result;
26860   return jresult;
26861 }
26862
26863
26864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26865   int jresult ;
26866   int result;
26867
26868   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26869   jresult = (int)result;
26870   return jresult;
26871 }
26872
26873
26874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26875   int jresult ;
26876   int result;
26877
26878   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26879   jresult = (int)result;
26880   return jresult;
26881 }
26882
26883
26884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26885   int jresult ;
26886   int result;
26887
26888   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26889   jresult = (int)result;
26890   return jresult;
26891 }
26892
26893
26894 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26895   void * jresult ;
26896   Dali::Renderer::Property *result = 0 ;
26897
26898   {
26899     try {
26900       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26901     } catch (std::out_of_range& e) {
26902       {
26903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26904       };
26905     } catch (std::exception& e) {
26906       {
26907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26908       };
26909     } catch (Dali::DaliException e) {
26910       {
26911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26912       };
26913     } catch (...) {
26914       {
26915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26916       };
26917     }
26918   }
26919
26920   jresult = (void *)result;
26921   return jresult;
26922 }
26923
26924
26925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26926   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26927
26928   arg1 = (Dali::Renderer::Property *)jarg1;
26929   {
26930     try {
26931       delete arg1;
26932     } catch (std::out_of_range& e) {
26933       {
26934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26935       };
26936     } catch (std::exception& e) {
26937       {
26938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26939       };
26940     } catch (Dali::DaliException e) {
26941       {
26942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26943       };
26944     } catch (...) {
26945       {
26946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26947       };
26948     }
26949   }
26950
26951 }
26952
26953
26954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26955   void * jresult ;
26956   Dali::Geometry *arg1 = 0 ;
26957   Dali::Shader *arg2 = 0 ;
26958   Dali::Renderer result;
26959
26960   arg1 = (Dali::Geometry *)jarg1;
26961   if (!arg1) {
26962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26963     return 0;
26964   }
26965   arg2 = (Dali::Shader *)jarg2;
26966   if (!arg2) {
26967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26968     return 0;
26969   }
26970   {
26971     try {
26972       result = Dali::Renderer::New(*arg1,*arg2);
26973     } catch (std::out_of_range& e) {
26974       {
26975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26976       };
26977     } catch (std::exception& e) {
26978       {
26979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26980       };
26981     } catch (Dali::DaliException e) {
26982       {
26983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26984       };
26985     } catch (...) {
26986       {
26987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26988       };
26989     }
26990   }
26991
26992   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26993   return jresult;
26994 }
26995
26996
26997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26998   void * jresult ;
26999   Dali::Renderer *result = 0 ;
27000
27001   {
27002     try {
27003       result = (Dali::Renderer *)new Dali::Renderer();
27004     } catch (std::out_of_range& e) {
27005       {
27006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27007       };
27008     } catch (std::exception& e) {
27009       {
27010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27011       };
27012     } catch (Dali::DaliException e) {
27013       {
27014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27015       };
27016     } catch (...) {
27017       {
27018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27019       };
27020     }
27021   }
27022
27023   jresult = (void *)result;
27024   return jresult;
27025 }
27026
27027
27028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
27029   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27030
27031   arg1 = (Dali::Renderer *)jarg1;
27032   {
27033     try {
27034       delete arg1;
27035     } catch (std::out_of_range& e) {
27036       {
27037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27038       };
27039     } catch (std::exception& e) {
27040       {
27041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27042       };
27043     } catch (Dali::DaliException e) {
27044       {
27045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27046       };
27047     } catch (...) {
27048       {
27049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27050       };
27051     }
27052   }
27053
27054 }
27055
27056
27057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
27058   void * jresult ;
27059   Dali::Renderer *arg1 = 0 ;
27060   Dali::Renderer *result = 0 ;
27061
27062   arg1 = (Dali::Renderer *)jarg1;
27063   if (!arg1) {
27064     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27065     return 0;
27066   }
27067   {
27068     try {
27069       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
27070     } catch (std::out_of_range& e) {
27071       {
27072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27073       };
27074     } catch (std::exception& e) {
27075       {
27076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27077       };
27078     } catch (Dali::DaliException e) {
27079       {
27080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27081       };
27082     } catch (...) {
27083       {
27084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27085       };
27086     }
27087   }
27088
27089   jresult = (void *)result;
27090   return jresult;
27091 }
27092
27093
27094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
27095   void * jresult ;
27096   Dali::BaseHandle arg1 ;
27097   Dali::BaseHandle *argp1 ;
27098   Dali::Renderer result;
27099
27100   argp1 = (Dali::BaseHandle *)jarg1;
27101   if (!argp1) {
27102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27103     return 0;
27104   }
27105   arg1 = *argp1;
27106   {
27107     try {
27108       result = Dali::Renderer::DownCast(arg1);
27109     } catch (std::out_of_range& e) {
27110       {
27111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27112       };
27113     } catch (std::exception& e) {
27114       {
27115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27116       };
27117     } catch (Dali::DaliException e) {
27118       {
27119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27120       };
27121     } catch (...) {
27122       {
27123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27124       };
27125     }
27126   }
27127
27128   jresult = new Dali::Renderer((const Dali::Renderer &)result);
27129   return jresult;
27130 }
27131
27132
27133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
27134   void * jresult ;
27135   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27136   Dali::Renderer *arg2 = 0 ;
27137   Dali::Renderer *result = 0 ;
27138
27139   arg1 = (Dali::Renderer *)jarg1;
27140   arg2 = (Dali::Renderer *)jarg2;
27141   if (!arg2) {
27142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
27143     return 0;
27144   }
27145   {
27146     try {
27147       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
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 (Dali::DaliException e) {
27157       {
27158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27159       };
27160     } catch (...) {
27161       {
27162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27163       };
27164     }
27165   }
27166
27167   jresult = (void *)result;
27168   return jresult;
27169 }
27170
27171
27172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
27173   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27174   Dali::Geometry *arg2 = 0 ;
27175
27176   arg1 = (Dali::Renderer *)jarg1;
27177   arg2 = (Dali::Geometry *)jarg2;
27178   if (!arg2) {
27179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
27180     return ;
27181   }
27182   {
27183     try {
27184       (arg1)->SetGeometry(*arg2);
27185     } catch (std::out_of_range& e) {
27186       {
27187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27188       };
27189     } catch (std::exception& e) {
27190       {
27191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27192       };
27193     } catch (Dali::DaliException e) {
27194       {
27195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27196       };
27197     } catch (...) {
27198       {
27199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27200       };
27201     }
27202   }
27203
27204 }
27205
27206
27207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
27208   void * jresult ;
27209   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27210   Dali::Geometry result;
27211
27212   arg1 = (Dali::Renderer *)jarg1;
27213   {
27214     try {
27215       result = ((Dali::Renderer const *)arg1)->GetGeometry();
27216     } catch (std::out_of_range& e) {
27217       {
27218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27219       };
27220     } catch (std::exception& e) {
27221       {
27222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27223       };
27224     } catch (Dali::DaliException e) {
27225       {
27226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27227       };
27228     } catch (...) {
27229       {
27230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27231       };
27232     }
27233   }
27234
27235   jresult = new Dali::Geometry((const Dali::Geometry &)result);
27236   return jresult;
27237 }
27238
27239
27240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
27241   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27242   int arg2 ;
27243   int arg3 ;
27244
27245   arg1 = (Dali::Renderer *)jarg1;
27246   arg2 = (int)jarg2;
27247   arg3 = (int)jarg3;
27248   {
27249     try {
27250       (arg1)->SetIndexRange(arg2,arg3);
27251     } catch (std::out_of_range& e) {
27252       {
27253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27254       };
27255     } catch (std::exception& e) {
27256       {
27257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27258       };
27259     } catch (Dali::DaliException e) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27262       };
27263     } catch (...) {
27264       {
27265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27266       };
27267     }
27268   }
27269
27270 }
27271
27272
27273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
27274   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27275   Dali::TextureSet *arg2 = 0 ;
27276
27277   arg1 = (Dali::Renderer *)jarg1;
27278   arg2 = (Dali::TextureSet *)jarg2;
27279   if (!arg2) {
27280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
27281     return ;
27282   }
27283   {
27284     try {
27285       (arg1)->SetTextures(*arg2);
27286     } catch (std::out_of_range& e) {
27287       {
27288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27289       };
27290     } catch (std::exception& e) {
27291       {
27292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27293       };
27294     } catch (Dali::DaliException e) {
27295       {
27296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27297       };
27298     } catch (...) {
27299       {
27300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27301       };
27302     }
27303   }
27304
27305 }
27306
27307
27308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
27309   void * jresult ;
27310   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27311   Dali::TextureSet result;
27312
27313   arg1 = (Dali::Renderer *)jarg1;
27314   {
27315     try {
27316       result = ((Dali::Renderer const *)arg1)->GetTextures();
27317     } catch (std::out_of_range& e) {
27318       {
27319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27320       };
27321     } catch (std::exception& e) {
27322       {
27323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27324       };
27325     } catch (Dali::DaliException e) {
27326       {
27327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27328       };
27329     } catch (...) {
27330       {
27331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27332       };
27333     }
27334   }
27335
27336   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27337   return jresult;
27338 }
27339
27340
27341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27342   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27343   Dali::Shader *arg2 = 0 ;
27344
27345   arg1 = (Dali::Renderer *)jarg1;
27346   arg2 = (Dali::Shader *)jarg2;
27347   if (!arg2) {
27348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27349     return ;
27350   }
27351   {
27352     try {
27353       (arg1)->SetShader(*arg2);
27354     } catch (std::out_of_range& e) {
27355       {
27356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27357       };
27358     } catch (std::exception& e) {
27359       {
27360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27361       };
27362     } catch (Dali::DaliException e) {
27363       {
27364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27365       };
27366     } catch (...) {
27367       {
27368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27369       };
27370     }
27371   }
27372
27373 }
27374
27375
27376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27377   void * jresult ;
27378   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27379   Dali::Shader result;
27380
27381   arg1 = (Dali::Renderer *)jarg1;
27382   {
27383     try {
27384       result = ((Dali::Renderer const *)arg1)->GetShader();
27385     } catch (std::out_of_range& e) {
27386       {
27387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27388       };
27389     } catch (std::exception& e) {
27390       {
27391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27392       };
27393     } catch (Dali::DaliException e) {
27394       {
27395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27396       };
27397     } catch (...) {
27398       {
27399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27400       };
27401     }
27402   }
27403
27404   jresult = new Dali::Shader((const Dali::Shader &)result);
27405   return jresult;
27406 }
27407
27408
27409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27410   void * jresult ;
27411   Dali::FrameBuffer::Attachment *result = 0 ;
27412
27413   {
27414     try {
27415       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27416     } catch (std::out_of_range& e) {
27417       {
27418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27419       };
27420     } catch (std::exception& e) {
27421       {
27422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27423       };
27424     } catch (Dali::DaliException e) {
27425       {
27426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27427       };
27428     } catch (...) {
27429       {
27430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27431       };
27432     }
27433   }
27434
27435   jresult = (void *)result;
27436   return jresult;
27437 }
27438
27439
27440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27441   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27442
27443   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27444   {
27445     try {
27446       delete arg1;
27447     } catch (std::out_of_range& e) {
27448       {
27449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27450       };
27451     } catch (std::exception& e) {
27452       {
27453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27454       };
27455     } catch (Dali::DaliException e) {
27456       {
27457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27458       };
27459     } catch (...) {
27460       {
27461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27462       };
27463     }
27464   }
27465
27466 }
27467
27468
27469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27470   void * jresult ;
27471   unsigned int arg1 ;
27472   unsigned int arg2 ;
27473   unsigned int arg3 ;
27474   Dali::FrameBuffer result;
27475
27476   arg1 = (unsigned int)jarg1;
27477   arg2 = (unsigned int)jarg2;
27478   arg3 = (unsigned int)jarg3;
27479   {
27480     try {
27481       result = Dali::FrameBuffer::New(arg1,arg2,arg3);
27482     } catch (std::out_of_range& e) {
27483       {
27484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27485       };
27486     } catch (std::exception& e) {
27487       {
27488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27489       };
27490     } catch (Dali::DaliException e) {
27491       {
27492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27493       };
27494     } catch (...) {
27495       {
27496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27497       };
27498     }
27499   }
27500
27501   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27502   return jresult;
27503 }
27504
27505
27506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27507   void * jresult ;
27508   Dali::FrameBuffer *result = 0 ;
27509
27510   {
27511     try {
27512       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27513     } catch (std::out_of_range& e) {
27514       {
27515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27516       };
27517     } catch (std::exception& e) {
27518       {
27519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27520       };
27521     } catch (Dali::DaliException e) {
27522       {
27523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27524       };
27525     } catch (...) {
27526       {
27527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27528       };
27529     }
27530   }
27531
27532   jresult = (void *)result;
27533   return jresult;
27534 }
27535
27536
27537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27538   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27539
27540   arg1 = (Dali::FrameBuffer *)jarg1;
27541   {
27542     try {
27543       delete arg1;
27544     } catch (std::out_of_range& e) {
27545       {
27546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27547       };
27548     } catch (std::exception& e) {
27549       {
27550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27551       };
27552     } catch (Dali::DaliException e) {
27553       {
27554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27555       };
27556     } catch (...) {
27557       {
27558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27559       };
27560     }
27561   }
27562
27563 }
27564
27565
27566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27567   void * jresult ;
27568   Dali::FrameBuffer *arg1 = 0 ;
27569   Dali::FrameBuffer *result = 0 ;
27570
27571   arg1 = (Dali::FrameBuffer *)jarg1;
27572   if (!arg1) {
27573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27574     return 0;
27575   }
27576   {
27577     try {
27578       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27579     } catch (std::out_of_range& e) {
27580       {
27581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27582       };
27583     } catch (std::exception& e) {
27584       {
27585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27586       };
27587     } catch (Dali::DaliException e) {
27588       {
27589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27590       };
27591     } catch (...) {
27592       {
27593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27594       };
27595     }
27596   }
27597
27598   jresult = (void *)result;
27599   return jresult;
27600 }
27601
27602
27603 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27604   void * jresult ;
27605   Dali::BaseHandle arg1 ;
27606   Dali::BaseHandle *argp1 ;
27607   Dali::FrameBuffer result;
27608
27609   argp1 = (Dali::BaseHandle *)jarg1;
27610   if (!argp1) {
27611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27612     return 0;
27613   }
27614   arg1 = *argp1;
27615   {
27616     try {
27617       result = Dali::FrameBuffer::DownCast(arg1);
27618     } catch (std::out_of_range& e) {
27619       {
27620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27621       };
27622     } catch (std::exception& e) {
27623       {
27624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27625       };
27626     } catch (Dali::DaliException e) {
27627       {
27628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27629       };
27630     } catch (...) {
27631       {
27632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27633       };
27634     }
27635   }
27636
27637   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27638   return jresult;
27639 }
27640
27641
27642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27643   void * jresult ;
27644   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27645   Dali::FrameBuffer *arg2 = 0 ;
27646   Dali::FrameBuffer *result = 0 ;
27647
27648   arg1 = (Dali::FrameBuffer *)jarg1;
27649   arg2 = (Dali::FrameBuffer *)jarg2;
27650   if (!arg2) {
27651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27652     return 0;
27653   }
27654   {
27655     try {
27656       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27657     } catch (std::out_of_range& e) {
27658       {
27659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27660       };
27661     } catch (std::exception& e) {
27662       {
27663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27664       };
27665     } catch (Dali::DaliException e) {
27666       {
27667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27668       };
27669     } catch (...) {
27670       {
27671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27672       };
27673     }
27674   }
27675
27676   jresult = (void *)result;
27677   return jresult;
27678 }
27679
27680
27681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27682   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27683   Dali::Texture *arg2 = 0 ;
27684
27685   arg1 = (Dali::FrameBuffer *)jarg1;
27686   arg2 = (Dali::Texture *)jarg2;
27687   if (!arg2) {
27688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27689     return ;
27690   }
27691   {
27692     try {
27693       (arg1)->AttachColorTexture(*arg2);
27694     } catch (std::out_of_range& e) {
27695       {
27696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27697       };
27698     } catch (std::exception& e) {
27699       {
27700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27701       };
27702     } catch (Dali::DaliException e) {
27703       {
27704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27705       };
27706     } catch (...) {
27707       {
27708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27709       };
27710     }
27711   }
27712
27713 }
27714
27715
27716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27717   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27718   Dali::Texture *arg2 = 0 ;
27719   unsigned int arg3 ;
27720   unsigned int arg4 ;
27721
27722   arg1 = (Dali::FrameBuffer *)jarg1;
27723   arg2 = (Dali::Texture *)jarg2;
27724   if (!arg2) {
27725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27726     return ;
27727   }
27728   arg3 = (unsigned int)jarg3;
27729   arg4 = (unsigned int)jarg4;
27730   {
27731     try {
27732       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27733     } catch (std::out_of_range& e) {
27734       {
27735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27736       };
27737     } catch (std::exception& e) {
27738       {
27739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27740       };
27741     } catch (Dali::DaliException e) {
27742       {
27743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27744       };
27745     } catch (...) {
27746       {
27747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27748       };
27749     }
27750   }
27751
27752 }
27753
27754
27755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27756   void * jresult ;
27757   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27758   Dali::Texture result;
27759
27760   arg1 = (Dali::FrameBuffer *)jarg1;
27761   {
27762     try {
27763       result = (arg1)->GetColorTexture();
27764     } catch (std::out_of_range& e) {
27765       {
27766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27767       };
27768     } catch (std::exception& e) {
27769       {
27770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27771       };
27772     } catch (Dali::DaliException e) {
27773       {
27774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27775       };
27776     } catch (...) {
27777       {
27778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27779       };
27780     }
27781   }
27782
27783   jresult = new Dali::Texture((const Dali::Texture &)result);
27784   return jresult;
27785 }
27786
27787
27788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27789   void * jresult ;
27790   Dali::RenderTaskList *result = 0 ;
27791
27792   {
27793     try {
27794       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27795     } catch (std::out_of_range& e) {
27796       {
27797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27798       };
27799     } catch (std::exception& e) {
27800       {
27801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27802       };
27803     } catch (Dali::DaliException e) {
27804       {
27805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27806       };
27807     } catch (...) {
27808       {
27809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27810       };
27811     }
27812   }
27813
27814   jresult = (void *)result;
27815   return jresult;
27816 }
27817
27818
27819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27820   void * jresult ;
27821   Dali::BaseHandle arg1 ;
27822   Dali::BaseHandle *argp1 ;
27823   Dali::RenderTaskList result;
27824
27825   argp1 = (Dali::BaseHandle *)jarg1;
27826   if (!argp1) {
27827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27828     return 0;
27829   }
27830   arg1 = *argp1;
27831   {
27832     try {
27833       result = Dali::RenderTaskList::DownCast(arg1);
27834     } catch (std::out_of_range& e) {
27835       {
27836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27837       };
27838     } catch (std::exception& e) {
27839       {
27840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27841       };
27842     } catch (Dali::DaliException e) {
27843       {
27844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27845       };
27846     } catch (...) {
27847       {
27848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27849       };
27850     }
27851   }
27852
27853   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27854   return jresult;
27855 }
27856
27857
27858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27859   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27860
27861   arg1 = (Dali::RenderTaskList *)jarg1;
27862   {
27863     try {
27864       delete arg1;
27865     } catch (std::out_of_range& e) {
27866       {
27867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27868       };
27869     } catch (std::exception& e) {
27870       {
27871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27872       };
27873     } catch (Dali::DaliException e) {
27874       {
27875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27876       };
27877     } catch (...) {
27878       {
27879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27880       };
27881     }
27882   }
27883
27884 }
27885
27886
27887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27888   void * jresult ;
27889   Dali::RenderTaskList *arg1 = 0 ;
27890   Dali::RenderTaskList *result = 0 ;
27891
27892   arg1 = (Dali::RenderTaskList *)jarg1;
27893   if (!arg1) {
27894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27895     return 0;
27896   }
27897   {
27898     try {
27899       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27900     } catch (std::out_of_range& e) {
27901       {
27902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27903       };
27904     } catch (std::exception& e) {
27905       {
27906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27907       };
27908     } catch (Dali::DaliException e) {
27909       {
27910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27911       };
27912     } catch (...) {
27913       {
27914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27915       };
27916     }
27917   }
27918
27919   jresult = (void *)result;
27920   return jresult;
27921 }
27922
27923
27924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27925   void * jresult ;
27926   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27927   Dali::RenderTaskList *arg2 = 0 ;
27928   Dali::RenderTaskList *result = 0 ;
27929
27930   arg1 = (Dali::RenderTaskList *)jarg1;
27931   arg2 = (Dali::RenderTaskList *)jarg2;
27932   if (!arg2) {
27933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27934     return 0;
27935   }
27936   {
27937     try {
27938       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27939     } catch (std::out_of_range& e) {
27940       {
27941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27942       };
27943     } catch (std::exception& e) {
27944       {
27945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27946       };
27947     } catch (Dali::DaliException e) {
27948       {
27949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27950       };
27951     } catch (...) {
27952       {
27953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27954       };
27955     }
27956   }
27957
27958   jresult = (void *)result;
27959   return jresult;
27960 }
27961
27962
27963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27964   void * jresult ;
27965   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27966   Dali::RenderTask result;
27967
27968   arg1 = (Dali::RenderTaskList *)jarg1;
27969   {
27970     try {
27971       result = (arg1)->CreateTask();
27972     } catch (std::out_of_range& e) {
27973       {
27974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27975       };
27976     } catch (std::exception& e) {
27977       {
27978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27979       };
27980     } catch (Dali::DaliException e) {
27981       {
27982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27983       };
27984     } catch (...) {
27985       {
27986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27987       };
27988     }
27989   }
27990
27991   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27992   return jresult;
27993 }
27994
27995
27996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27997   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27998   Dali::RenderTask arg2 ;
27999   Dali::RenderTask *argp2 ;
28000
28001   arg1 = (Dali::RenderTaskList *)jarg1;
28002   argp2 = (Dali::RenderTask *)jarg2;
28003   if (!argp2) {
28004     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
28005     return ;
28006   }
28007   arg2 = *argp2;
28008   {
28009     try {
28010       (arg1)->RemoveTask(arg2);
28011     } catch (std::out_of_range& e) {
28012       {
28013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28014       };
28015     } catch (std::exception& e) {
28016       {
28017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28018       };
28019     } catch (Dali::DaliException e) {
28020       {
28021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28022       };
28023     } catch (...) {
28024       {
28025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28026       };
28027     }
28028   }
28029
28030 }
28031
28032
28033 //// ===============================================end part 1 =================
28034
28035 //// ========================= part 2 ===============================
28036
28037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
28038   unsigned int jresult ;
28039   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28040   unsigned int result;
28041
28042   arg1 = (Dali::RenderTaskList *)jarg1;
28043   {
28044     try {
28045       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
28046     } catch (std::out_of_range& e) {
28047       {
28048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28049       };
28050     } catch (std::exception& e) {
28051       {
28052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28053       };
28054     } catch (Dali::DaliException e) {
28055       {
28056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28057       };
28058     } catch (...) {
28059       {
28060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28061       };
28062     }
28063   }
28064
28065   jresult = result;
28066   return jresult;
28067 }
28068
28069
28070 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
28071   void * jresult ;
28072   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
28073   unsigned int arg2 ;
28074   Dali::RenderTask result;
28075
28076   arg1 = (Dali::RenderTaskList *)jarg1;
28077   arg2 = (unsigned int)jarg2;
28078   {
28079     try {
28080       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
28081     } catch (std::out_of_range& e) {
28082       {
28083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28084       };
28085     } catch (std::exception& e) {
28086       {
28087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28088       };
28089     } catch (Dali::DaliException e) {
28090       {
28091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28092       };
28093     } catch (...) {
28094       {
28095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28096       };
28097     }
28098   }
28099
28100   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28101   return jresult;
28102 }
28103
28104
28105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
28106   int jresult ;
28107   int result;
28108
28109   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
28110   jresult = (int)result;
28111   return jresult;
28112 }
28113
28114
28115 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
28116   int jresult ;
28117   int result;
28118
28119   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
28120   jresult = (int)result;
28121   return jresult;
28122 }
28123
28124
28125 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
28126   int jresult ;
28127   int result;
28128
28129   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
28130   jresult = (int)result;
28131   return jresult;
28132 }
28133
28134
28135 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
28136   int jresult ;
28137   int result;
28138
28139   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
28140   jresult = (int)result;
28141   return jresult;
28142 }
28143
28144
28145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
28146   void * jresult ;
28147   Dali::RenderTask::Property *result = 0 ;
28148
28149   {
28150     try {
28151       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
28152     } catch (std::out_of_range& e) {
28153       {
28154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28155       };
28156     } catch (std::exception& e) {
28157       {
28158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28159       };
28160     } catch (Dali::DaliException e) {
28161       {
28162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28163       };
28164     } catch (...) {
28165       {
28166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28167       };
28168     }
28169   }
28170
28171   jresult = (void *)result;
28172   return jresult;
28173 }
28174
28175
28176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
28177   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
28178
28179   arg1 = (Dali::RenderTask::Property *)jarg1;
28180   {
28181     try {
28182       delete arg1;
28183     } catch (std::out_of_range& e) {
28184       {
28185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28186       };
28187     } catch (std::exception& e) {
28188       {
28189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28190       };
28191     } catch (Dali::DaliException e) {
28192       {
28193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28194       };
28195     } catch (...) {
28196       {
28197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28198       };
28199     }
28200   }
28201
28202 }
28203
28204
28205 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
28206   void * jresult ;
28207   bool (*result)(Dali::Vector2 &) = 0 ;
28208
28209   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
28210   jresult = (void *)result;
28211   return jresult;
28212 }
28213
28214
28215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
28216   void * jresult ;
28217   bool (*result)(Dali::Vector2 &) = 0 ;
28218
28219   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
28220   jresult = (void *)result;
28221   return jresult;
28222 }
28223
28224
28225 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
28226   unsigned int jresult ;
28227   bool result;
28228
28229   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
28230   jresult = result;
28231   return jresult;
28232 }
28233
28234
28235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
28236   unsigned int jresult ;
28237   bool result;
28238
28239   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
28240   jresult = result;
28241   return jresult;
28242 }
28243
28244
28245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
28246   void * jresult ;
28247   Dali::Vector4 *result = 0 ;
28248
28249   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
28250   jresult = (void *)result;
28251   return jresult;
28252 }
28253
28254
28255 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
28256   unsigned int jresult ;
28257   bool result;
28258
28259   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
28260   jresult = result;
28261   return jresult;
28262 }
28263
28264
28265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
28266   unsigned int jresult ;
28267   bool result;
28268
28269   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
28270   jresult = result;
28271   return jresult;
28272 }
28273
28274
28275 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
28276   unsigned int jresult ;
28277   unsigned int result;
28278
28279   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
28280   jresult = result;
28281   return jresult;
28282 }
28283
28284
28285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
28286   void * jresult ;
28287   Dali::RenderTask *result = 0 ;
28288
28289   {
28290     try {
28291       result = (Dali::RenderTask *)new Dali::RenderTask();
28292     } catch (std::out_of_range& e) {
28293       {
28294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28295       };
28296     } catch (std::exception& e) {
28297       {
28298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28299       };
28300     } catch (Dali::DaliException e) {
28301       {
28302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28303       };
28304     } catch (...) {
28305       {
28306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28307       };
28308     }
28309   }
28310
28311   jresult = (void *)result;
28312   return jresult;
28313 }
28314
28315
28316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
28317   void * jresult ;
28318   Dali::BaseHandle arg1 ;
28319   Dali::BaseHandle *argp1 ;
28320   Dali::RenderTask result;
28321
28322   argp1 = (Dali::BaseHandle *)jarg1;
28323   if (!argp1) {
28324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
28325     return 0;
28326   }
28327   arg1 = *argp1;
28328   {
28329     try {
28330       result = Dali::RenderTask::DownCast(arg1);
28331     } catch (std::out_of_range& e) {
28332       {
28333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28334       };
28335     } catch (std::exception& e) {
28336       {
28337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28338       };
28339     } catch (Dali::DaliException e) {
28340       {
28341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28342       };
28343     } catch (...) {
28344       {
28345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28346       };
28347     }
28348   }
28349
28350   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28351   return jresult;
28352 }
28353
28354
28355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28356   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28357
28358   arg1 = (Dali::RenderTask *)jarg1;
28359   {
28360     try {
28361       delete arg1;
28362     } catch (std::out_of_range& e) {
28363       {
28364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28365       };
28366     } catch (std::exception& e) {
28367       {
28368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28369       };
28370     } catch (Dali::DaliException e) {
28371       {
28372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28373       };
28374     } catch (...) {
28375       {
28376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28377       };
28378     }
28379   }
28380
28381 }
28382
28383
28384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28385   void * jresult ;
28386   Dali::RenderTask *arg1 = 0 ;
28387   Dali::RenderTask *result = 0 ;
28388
28389   arg1 = (Dali::RenderTask *)jarg1;
28390   if (!arg1) {
28391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28392     return 0;
28393   }
28394   {
28395     try {
28396       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28397     } catch (std::out_of_range& e) {
28398       {
28399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28400       };
28401     } catch (std::exception& e) {
28402       {
28403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28404       };
28405     } catch (Dali::DaliException e) {
28406       {
28407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28408       };
28409     } catch (...) {
28410       {
28411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28412       };
28413     }
28414   }
28415
28416   jresult = (void *)result;
28417   return jresult;
28418 }
28419
28420
28421 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28422   void * jresult ;
28423   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28424   Dali::RenderTask *arg2 = 0 ;
28425   Dali::RenderTask *result = 0 ;
28426
28427   arg1 = (Dali::RenderTask *)jarg1;
28428   arg2 = (Dali::RenderTask *)jarg2;
28429   if (!arg2) {
28430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28431     return 0;
28432   }
28433   {
28434     try {
28435       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28436     } catch (std::out_of_range& e) {
28437       {
28438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28439       };
28440     } catch (std::exception& e) {
28441       {
28442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28443       };
28444     } catch (Dali::DaliException e) {
28445       {
28446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28447       };
28448     } catch (...) {
28449       {
28450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28451       };
28452     }
28453   }
28454
28455   jresult = (void *)result;
28456   return jresult;
28457 }
28458
28459
28460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28461   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28462   Dali::Actor arg2 ;
28463   Dali::Actor *argp2 ;
28464
28465   arg1 = (Dali::RenderTask *)jarg1;
28466   argp2 = (Dali::Actor *)jarg2;
28467   if (!argp2) {
28468     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28469     return ;
28470   }
28471   arg2 = *argp2;
28472   {
28473     try {
28474       (arg1)->SetSourceActor(arg2);
28475     } catch (std::out_of_range& e) {
28476       {
28477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28478       };
28479     } catch (std::exception& e) {
28480       {
28481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28482       };
28483     } catch (Dali::DaliException e) {
28484       {
28485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28486       };
28487     } catch (...) {
28488       {
28489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28490       };
28491     }
28492   }
28493
28494 }
28495
28496
28497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28498   void * jresult ;
28499   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28500   Dali::Actor result;
28501
28502   arg1 = (Dali::RenderTask *)jarg1;
28503   {
28504     try {
28505       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28506     } catch (std::out_of_range& e) {
28507       {
28508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28509       };
28510     } catch (std::exception& e) {
28511       {
28512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28513       };
28514     } catch (Dali::DaliException e) {
28515       {
28516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28517       };
28518     } catch (...) {
28519       {
28520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28521       };
28522     }
28523   }
28524
28525   jresult = new Dali::Actor((const Dali::Actor &)result);
28526   return jresult;
28527 }
28528
28529
28530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28531   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28532   bool arg2 ;
28533
28534   arg1 = (Dali::RenderTask *)jarg1;
28535   arg2 = jarg2 ? true : false;
28536   {
28537     try {
28538       (arg1)->SetExclusive(arg2);
28539     } catch (std::out_of_range& e) {
28540       {
28541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28542       };
28543     } catch (std::exception& e) {
28544       {
28545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28546       };
28547     } catch (Dali::DaliException e) {
28548       {
28549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28550       };
28551     } catch (...) {
28552       {
28553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28554       };
28555     }
28556   }
28557
28558 }
28559
28560
28561 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28562   unsigned int jresult ;
28563   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28564   bool result;
28565
28566   arg1 = (Dali::RenderTask *)jarg1;
28567   {
28568     try {
28569       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28570     } catch (std::out_of_range& e) {
28571       {
28572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28573       };
28574     } catch (std::exception& e) {
28575       {
28576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28577       };
28578     } catch (Dali::DaliException e) {
28579       {
28580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28581       };
28582     } catch (...) {
28583       {
28584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28585       };
28586     }
28587   }
28588
28589   jresult = result;
28590   return jresult;
28591 }
28592
28593
28594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28595   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28596   bool arg2 ;
28597
28598   arg1 = (Dali::RenderTask *)jarg1;
28599   arg2 = jarg2 ? true : false;
28600   {
28601     try {
28602       (arg1)->SetInputEnabled(arg2);
28603     } catch (std::out_of_range& e) {
28604       {
28605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28606       };
28607     } catch (std::exception& e) {
28608       {
28609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28610       };
28611     } catch (Dali::DaliException e) {
28612       {
28613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28614       };
28615     } catch (...) {
28616       {
28617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28618       };
28619     }
28620   }
28621
28622 }
28623
28624
28625 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28626   unsigned int jresult ;
28627   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28628   bool result;
28629
28630   arg1 = (Dali::RenderTask *)jarg1;
28631   {
28632     try {
28633       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28634     } catch (std::out_of_range& e) {
28635       {
28636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28637       };
28638     } catch (std::exception& e) {
28639       {
28640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28641       };
28642     } catch (Dali::DaliException e) {
28643       {
28644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28645       };
28646     } catch (...) {
28647       {
28648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28649       };
28650     }
28651   }
28652
28653   jresult = result;
28654   return jresult;
28655 }
28656
28657
28658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28659   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28660   Dali::CameraActor arg2 ;
28661   Dali::CameraActor *argp2 ;
28662
28663   arg1 = (Dali::RenderTask *)jarg1;
28664   argp2 = (Dali::CameraActor *)jarg2;
28665   if (!argp2) {
28666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28667     return ;
28668   }
28669   arg2 = *argp2;
28670   {
28671     try {
28672       (arg1)->SetCameraActor(arg2);
28673     } catch (std::out_of_range& e) {
28674       {
28675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28676       };
28677     } catch (std::exception& e) {
28678       {
28679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28680       };
28681     } catch (Dali::DaliException e) {
28682       {
28683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28684       };
28685     } catch (...) {
28686       {
28687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28688       };
28689     }
28690   }
28691
28692 }
28693
28694
28695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28696   void * jresult ;
28697   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28698   Dali::CameraActor result;
28699
28700   arg1 = (Dali::RenderTask *)jarg1;
28701   {
28702     try {
28703       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28704     } catch (std::out_of_range& e) {
28705       {
28706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28707       };
28708     } catch (std::exception& e) {
28709       {
28710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28711       };
28712     } catch (Dali::DaliException e) {
28713       {
28714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28715       };
28716     } catch (...) {
28717       {
28718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28719       };
28720     }
28721   }
28722
28723   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28724   return jresult;
28725 }
28726
28727
28728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetTargetFrameBuffer(void * jarg1, void * jarg2) {
28729   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28730   Dali::FrameBufferImage arg2 ;
28731   Dali::FrameBufferImage *argp2 ;
28732
28733   arg1 = (Dali::RenderTask *)jarg1;
28734   argp2 = (Dali::FrameBufferImage *)jarg2;
28735   if (!argp2) {
28736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBufferImage", 0);
28737     return ;
28738   }
28739   arg2 = *argp2;
28740   {
28741     try {
28742       (arg1)->SetTargetFrameBuffer(arg2);
28743     } catch (std::out_of_range& e) {
28744       {
28745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28746       };
28747     } catch (std::exception& e) {
28748       {
28749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28750       };
28751     } catch (Dali::DaliException e) {
28752       {
28753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28754       };
28755     } catch (...) {
28756       {
28757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28758       };
28759     }
28760   }
28761
28762 }
28763
28764
28765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetTargetFrameBuffer(void * jarg1) {
28766   void * jresult ;
28767   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28768   Dali::FrameBufferImage result;
28769
28770   arg1 = (Dali::RenderTask *)jarg1;
28771   {
28772     try {
28773       result = ((Dali::RenderTask const *)arg1)->GetTargetFrameBuffer();
28774     } catch (std::out_of_range& e) {
28775       {
28776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28777       };
28778     } catch (std::exception& e) {
28779       {
28780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28781       };
28782     } catch (Dali::DaliException e) {
28783       {
28784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28785       };
28786     } catch (...) {
28787       {
28788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28789       };
28790     }
28791   }
28792
28793   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
28794   return jresult;
28795 }
28796
28797
28798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28799   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28800   Dali::FrameBuffer arg2 ;
28801   Dali::FrameBuffer *argp2 ;
28802
28803   arg1 = (Dali::RenderTask *)jarg1;
28804   argp2 = (Dali::FrameBuffer *)jarg2;
28805   if (!argp2) {
28806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28807     return ;
28808   }
28809   arg2 = *argp2;
28810   {
28811     try {
28812       (arg1)->SetFrameBuffer(arg2);
28813     } catch (std::out_of_range& e) {
28814       {
28815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28816       };
28817     } catch (std::exception& e) {
28818       {
28819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28820       };
28821     } catch (Dali::DaliException e) {
28822       {
28823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28824       };
28825     } catch (...) {
28826       {
28827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28828       };
28829     }
28830   }
28831
28832 }
28833
28834
28835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28836   void * jresult ;
28837   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28838   Dali::FrameBuffer result;
28839
28840   arg1 = (Dali::RenderTask *)jarg1;
28841   {
28842     try {
28843       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28844     } catch (std::out_of_range& e) {
28845       {
28846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28847       };
28848     } catch (std::exception& e) {
28849       {
28850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28851       };
28852     } catch (Dali::DaliException e) {
28853       {
28854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28855       };
28856     } catch (...) {
28857       {
28858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28859       };
28860     }
28861   }
28862
28863   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28864   return jresult;
28865 }
28866
28867
28868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28869   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28870   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28871
28872   arg1 = (Dali::RenderTask *)jarg1;
28873   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28874   {
28875     try {
28876       (arg1)->SetScreenToFrameBufferFunction(arg2);
28877     } catch (std::out_of_range& e) {
28878       {
28879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28880       };
28881     } catch (std::exception& e) {
28882       {
28883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28884       };
28885     } catch (Dali::DaliException e) {
28886       {
28887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28888       };
28889     } catch (...) {
28890       {
28891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28892       };
28893     }
28894   }
28895
28896 }
28897
28898
28899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28900   void * jresult ;
28901   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28902   Dali::RenderTask::ScreenToFrameBufferFunction result;
28903
28904   arg1 = (Dali::RenderTask *)jarg1;
28905   {
28906     try {
28907       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28908     } catch (std::out_of_range& e) {
28909       {
28910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28911       };
28912     } catch (std::exception& e) {
28913       {
28914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28915       };
28916     } catch (Dali::DaliException e) {
28917       {
28918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28919       };
28920     } catch (...) {
28921       {
28922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28923       };
28924     }
28925   }
28926
28927   jresult = (void *)result;
28928   return jresult;
28929 }
28930
28931
28932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28933   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28934   Dali::Actor arg2 ;
28935   Dali::Actor *argp2 ;
28936
28937   arg1 = (Dali::RenderTask *)jarg1;
28938   argp2 = (Dali::Actor *)jarg2;
28939   if (!argp2) {
28940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28941     return ;
28942   }
28943   arg2 = *argp2;
28944   {
28945     try {
28946       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28947     } catch (std::out_of_range& e) {
28948       {
28949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28950       };
28951     } catch (std::exception& e) {
28952       {
28953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28954       };
28955     } catch (Dali::DaliException e) {
28956       {
28957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28958       };
28959     } catch (...) {
28960       {
28961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28962       };
28963     }
28964   }
28965
28966 }
28967
28968
28969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28970   void * jresult ;
28971   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28972   Dali::Actor result;
28973
28974   arg1 = (Dali::RenderTask *)jarg1;
28975   {
28976     try {
28977       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28978     } catch (std::out_of_range& e) {
28979       {
28980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28981       };
28982     } catch (std::exception& e) {
28983       {
28984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28985       };
28986     } catch (Dali::DaliException e) {
28987       {
28988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28989       };
28990     } catch (...) {
28991       {
28992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28993       };
28994     }
28995   }
28996
28997   jresult = new Dali::Actor((const Dali::Actor &)result);
28998   return jresult;
28999 }
29000
29001
29002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
29003   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29004   Dali::Vector2 arg2 ;
29005   Dali::Vector2 *argp2 ;
29006
29007   arg1 = (Dali::RenderTask *)jarg1;
29008   argp2 = (Dali::Vector2 *)jarg2;
29009   if (!argp2) {
29010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29011     return ;
29012   }
29013   arg2 = *argp2;
29014   {
29015     try {
29016       (arg1)->SetViewportPosition(arg2);
29017     } catch (std::out_of_range& e) {
29018       {
29019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29020       };
29021     } catch (std::exception& e) {
29022       {
29023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29024       };
29025     } catch (Dali::DaliException e) {
29026       {
29027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29028       };
29029     } catch (...) {
29030       {
29031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29032       };
29033     }
29034   }
29035
29036 }
29037
29038
29039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
29040   void * jresult ;
29041   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29042   Dali::Vector2 result;
29043
29044   arg1 = (Dali::RenderTask *)jarg1;
29045   {
29046     try {
29047       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
29048     } catch (std::out_of_range& e) {
29049       {
29050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29051       };
29052     } catch (std::exception& e) {
29053       {
29054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29055       };
29056     } catch (Dali::DaliException e) {
29057       {
29058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29059       };
29060     } catch (...) {
29061       {
29062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29063       };
29064     }
29065   }
29066
29067   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29068   return jresult;
29069 }
29070
29071
29072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
29073   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29074   Dali::Vector2 arg2 ;
29075   Dali::Vector2 *argp2 ;
29076
29077   arg1 = (Dali::RenderTask *)jarg1;
29078   argp2 = (Dali::Vector2 *)jarg2;
29079   if (!argp2) {
29080     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
29081     return ;
29082   }
29083   arg2 = *argp2;
29084   {
29085     try {
29086       (arg1)->SetViewportSize(arg2);
29087     } catch (std::out_of_range& e) {
29088       {
29089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29090       };
29091     } catch (std::exception& e) {
29092       {
29093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29094       };
29095     } catch (Dali::DaliException e) {
29096       {
29097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29098       };
29099     } catch (...) {
29100       {
29101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29102       };
29103     }
29104   }
29105
29106 }
29107
29108
29109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
29110   void * jresult ;
29111   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29112   Dali::Vector2 result;
29113
29114   arg1 = (Dali::RenderTask *)jarg1;
29115   {
29116     try {
29117       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
29118     } catch (std::out_of_range& e) {
29119       {
29120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29121       };
29122     } catch (std::exception& e) {
29123       {
29124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29125       };
29126     } catch (Dali::DaliException e) {
29127       {
29128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29129       };
29130     } catch (...) {
29131       {
29132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29133       };
29134     }
29135   }
29136
29137   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
29138   return jresult;
29139 }
29140
29141
29142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
29143   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29144   Dali::Viewport arg2 ;
29145   Dali::Viewport *argp2 ;
29146
29147   arg1 = (Dali::RenderTask *)jarg1;
29148   argp2 = (Dali::Viewport *)jarg2;
29149   if (!argp2) {
29150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
29151     return ;
29152   }
29153   arg2 = *argp2;
29154   {
29155     try {
29156       (arg1)->SetViewport(arg2);
29157     } catch (std::out_of_range& e) {
29158       {
29159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29160       };
29161     } catch (std::exception& e) {
29162       {
29163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29164       };
29165     } catch (Dali::DaliException e) {
29166       {
29167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29168       };
29169     } catch (...) {
29170       {
29171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29172       };
29173     }
29174   }
29175
29176 }
29177
29178
29179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
29180   void * jresult ;
29181   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29182   Dali::Viewport result;
29183
29184   arg1 = (Dali::RenderTask *)jarg1;
29185   {
29186     try {
29187       result = ((Dali::RenderTask const *)arg1)->GetViewport();
29188     } catch (std::out_of_range& e) {
29189       {
29190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29191       };
29192     } catch (std::exception& e) {
29193       {
29194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29195       };
29196     } catch (Dali::DaliException e) {
29197       {
29198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29199       };
29200     } catch (...) {
29201       {
29202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29203       };
29204     }
29205   }
29206
29207   jresult = new Dali::Viewport((const Dali::Viewport &)result);
29208   return jresult;
29209 }
29210
29211
29212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
29213   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29214   Dali::Vector4 *arg2 = 0 ;
29215
29216   arg1 = (Dali::RenderTask *)jarg1;
29217   arg2 = (Dali::Vector4 *)jarg2;
29218   if (!arg2) {
29219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
29220     return ;
29221   }
29222   {
29223     try {
29224       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
29225     } catch (std::out_of_range& e) {
29226       {
29227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29228       };
29229     } catch (std::exception& e) {
29230       {
29231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29232       };
29233     } catch (Dali::DaliException e) {
29234       {
29235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29236       };
29237     } catch (...) {
29238       {
29239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29240       };
29241     }
29242   }
29243
29244 }
29245
29246
29247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
29248   void * jresult ;
29249   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29250   Dali::Vector4 result;
29251
29252   arg1 = (Dali::RenderTask *)jarg1;
29253   {
29254     try {
29255       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
29256     } catch (std::out_of_range& e) {
29257       {
29258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29259       };
29260     } catch (std::exception& e) {
29261       {
29262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29263       };
29264     } catch (Dali::DaliException e) {
29265       {
29266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29267       };
29268     } catch (...) {
29269       {
29270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29271       };
29272     }
29273   }
29274
29275   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
29276   return jresult;
29277 }
29278
29279
29280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
29281   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29282   bool arg2 ;
29283
29284   arg1 = (Dali::RenderTask *)jarg1;
29285   arg2 = jarg2 ? true : false;
29286   {
29287     try {
29288       (arg1)->SetClearEnabled(arg2);
29289     } catch (std::out_of_range& e) {
29290       {
29291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29292       };
29293     } catch (std::exception& e) {
29294       {
29295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29296       };
29297     } catch (Dali::DaliException e) {
29298       {
29299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29300       };
29301     } catch (...) {
29302       {
29303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29304       };
29305     }
29306   }
29307
29308 }
29309
29310
29311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
29312   unsigned int jresult ;
29313   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29314   bool result;
29315
29316   arg1 = (Dali::RenderTask *)jarg1;
29317   {
29318     try {
29319       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
29320     } catch (std::out_of_range& e) {
29321       {
29322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29323       };
29324     } catch (std::exception& e) {
29325       {
29326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29327       };
29328     } catch (Dali::DaliException e) {
29329       {
29330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29331       };
29332     } catch (...) {
29333       {
29334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29335       };
29336     }
29337   }
29338
29339   jresult = result;
29340   return jresult;
29341 }
29342
29343
29344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
29345   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29346   bool arg2 ;
29347
29348   arg1 = (Dali::RenderTask *)jarg1;
29349   arg2 = jarg2 ? true : false;
29350   {
29351     try {
29352       (arg1)->SetCullMode(arg2);
29353     } catch (std::out_of_range& e) {
29354       {
29355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29356       };
29357     } catch (std::exception& e) {
29358       {
29359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29360       };
29361     } catch (Dali::DaliException e) {
29362       {
29363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29364       };
29365     } catch (...) {
29366       {
29367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29368       };
29369     }
29370   }
29371
29372 }
29373
29374
29375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
29376   unsigned int jresult ;
29377   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29378   bool result;
29379
29380   arg1 = (Dali::RenderTask *)jarg1;
29381   {
29382     try {
29383       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
29384     } catch (std::out_of_range& e) {
29385       {
29386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29387       };
29388     } catch (std::exception& e) {
29389       {
29390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29391       };
29392     } catch (Dali::DaliException e) {
29393       {
29394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29395       };
29396     } catch (...) {
29397       {
29398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29399       };
29400     }
29401   }
29402
29403   jresult = result;
29404   return jresult;
29405 }
29406
29407
29408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29409   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29410   unsigned int arg2 ;
29411
29412   arg1 = (Dali::RenderTask *)jarg1;
29413   arg2 = (unsigned int)jarg2;
29414   {
29415     try {
29416       (arg1)->SetRefreshRate(arg2);
29417     } catch (std::out_of_range& e) {
29418       {
29419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29420       };
29421     } catch (std::exception& e) {
29422       {
29423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29424       };
29425     } catch (Dali::DaliException e) {
29426       {
29427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29428       };
29429     } catch (...) {
29430       {
29431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29432       };
29433     }
29434   }
29435
29436 }
29437
29438
29439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29440   unsigned int jresult ;
29441   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29442   unsigned int result;
29443
29444   arg1 = (Dali::RenderTask *)jarg1;
29445   {
29446     try {
29447       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
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 (Dali::DaliException e) {
29457       {
29458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29459       };
29460     } catch (...) {
29461       {
29462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29463       };
29464     }
29465   }
29466
29467   jresult = result;
29468   return jresult;
29469 }
29470
29471
29472 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29473   unsigned int jresult ;
29474   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29475   Dali::Vector3 *arg2 = 0 ;
29476   float *arg3 = 0 ;
29477   float *arg4 = 0 ;
29478   bool result;
29479
29480   arg1 = (Dali::RenderTask *)jarg1;
29481   arg2 = (Dali::Vector3 *)jarg2;
29482   if (!arg2) {
29483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29484     return 0;
29485   }
29486   arg3 = (float *)jarg3;
29487   arg4 = (float *)jarg4;
29488   {
29489     try {
29490       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29491     } catch (std::out_of_range& e) {
29492       {
29493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29494       };
29495     } catch (std::exception& e) {
29496       {
29497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29498       };
29499     } catch (Dali::DaliException e) {
29500       {
29501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29502       };
29503     } catch (...) {
29504       {
29505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29506       };
29507     }
29508   }
29509
29510   jresult = result;
29511   return jresult;
29512 }
29513
29514
29515 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29516   unsigned int jresult ;
29517   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29518   Dali::Actor arg2 ;
29519   float arg3 ;
29520   float arg4 ;
29521   float *arg5 = 0 ;
29522   float *arg6 = 0 ;
29523   Dali::Actor *argp2 ;
29524   bool result;
29525
29526   arg1 = (Dali::RenderTask *)jarg1;
29527   argp2 = (Dali::Actor *)jarg2;
29528   if (!argp2) {
29529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29530     return 0;
29531   }
29532   arg2 = *argp2;
29533   arg3 = (float)jarg3;
29534   arg4 = (float)jarg4;
29535   arg5 = (float *)jarg5;
29536   arg6 = (float *)jarg6;
29537   {
29538     try {
29539       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29540     } catch (std::out_of_range& e) {
29541       {
29542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29543       };
29544     } catch (std::exception& e) {
29545       {
29546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29547       };
29548     } catch (Dali::DaliException e) {
29549       {
29550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29551       };
29552     } catch (...) {
29553       {
29554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29555       };
29556     }
29557   }
29558
29559   jresult = result;
29560   return jresult;
29561 }
29562
29563
29564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29565   void * jresult ;
29566   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29567   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29568
29569   arg1 = (Dali::RenderTask *)jarg1;
29570   {
29571     try {
29572       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29573     } catch (std::out_of_range& e) {
29574       {
29575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29576       };
29577     } catch (std::exception& e) {
29578       {
29579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29580       };
29581     } catch (Dali::DaliException e) {
29582       {
29583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29584       };
29585     } catch (...) {
29586       {
29587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29588       };
29589     }
29590   }
29591
29592   jresult = (void *)result;
29593   return jresult;
29594 }
29595
29596
29597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29598   void * jresult ;
29599   int arg1 ;
29600   Dali::TouchPoint::State arg2 ;
29601   float arg3 ;
29602   float arg4 ;
29603   Dali::TouchPoint *result = 0 ;
29604
29605   arg1 = (int)jarg1;
29606   arg2 = (Dali::TouchPoint::State)jarg2;
29607   arg3 = (float)jarg3;
29608   arg4 = (float)jarg4;
29609   {
29610     try {
29611       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29612     } catch (std::out_of_range& e) {
29613       {
29614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29615       };
29616     } catch (std::exception& e) {
29617       {
29618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29619       };
29620     } catch (Dali::DaliException e) {
29621       {
29622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29623       };
29624     } catch (...) {
29625       {
29626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29627       };
29628     }
29629   }
29630
29631   jresult = (void *)result;
29632   return jresult;
29633 }
29634
29635
29636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29637   void * jresult ;
29638   int arg1 ;
29639   Dali::TouchPoint::State arg2 ;
29640   float arg3 ;
29641   float arg4 ;
29642   float arg5 ;
29643   float arg6 ;
29644   Dali::TouchPoint *result = 0 ;
29645
29646   arg1 = (int)jarg1;
29647   arg2 = (Dali::TouchPoint::State)jarg2;
29648   arg3 = (float)jarg3;
29649   arg4 = (float)jarg4;
29650   arg5 = (float)jarg5;
29651   arg6 = (float)jarg6;
29652   {
29653     try {
29654       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29655     } catch (std::out_of_range& e) {
29656       {
29657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29658       };
29659     } catch (std::exception& e) {
29660       {
29661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29662       };
29663     } catch (Dali::DaliException e) {
29664       {
29665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29666       };
29667     } catch (...) {
29668       {
29669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29670       };
29671     }
29672   }
29673
29674   jresult = (void *)result;
29675   return jresult;
29676 }
29677
29678
29679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29680   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29681
29682   arg1 = (Dali::TouchPoint *)jarg1;
29683   {
29684     try {
29685       delete arg1;
29686     } catch (std::out_of_range& e) {
29687       {
29688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29689       };
29690     } catch (std::exception& e) {
29691       {
29692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29693       };
29694     } catch (Dali::DaliException e) {
29695       {
29696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29697       };
29698     } catch (...) {
29699       {
29700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29701       };
29702     }
29703   }
29704
29705 }
29706
29707
29708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29709   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29710   int arg2 ;
29711
29712   arg1 = (Dali::TouchPoint *)jarg1;
29713   arg2 = (int)jarg2;
29714   if (arg1) (arg1)->deviceId = arg2;
29715 }
29716
29717
29718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29719   int jresult ;
29720   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29721   int result;
29722
29723   arg1 = (Dali::TouchPoint *)jarg1;
29724   result = (int) ((arg1)->deviceId);
29725   jresult = result;
29726   return jresult;
29727 }
29728
29729
29730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29731   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29732   Dali::TouchPoint::State arg2 ;
29733
29734   arg1 = (Dali::TouchPoint *)jarg1;
29735   arg2 = (Dali::TouchPoint::State)jarg2;
29736   if (arg1) (arg1)->state = arg2;
29737 }
29738
29739
29740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29741   int jresult ;
29742   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29743   Dali::TouchPoint::State result;
29744
29745   arg1 = (Dali::TouchPoint *)jarg1;
29746   result = (Dali::TouchPoint::State) ((arg1)->state);
29747   jresult = (int)result;
29748   return jresult;
29749 }
29750
29751
29752 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29753   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29754   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29755
29756   arg1 = (Dali::TouchPoint *)jarg1;
29757   arg2 = (Dali::Actor *)jarg2;
29758   if (arg1) (arg1)->hitActor = *arg2;
29759 }
29760
29761
29762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29763   void * jresult ;
29764   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29765   Dali::Actor *result = 0 ;
29766
29767   arg1 = (Dali::TouchPoint *)jarg1;
29768   result = (Dali::Actor *)& ((arg1)->hitActor);
29769   jresult = (void *)result;
29770   return jresult;
29771 }
29772
29773
29774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29775   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29776   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29777
29778   arg1 = (Dali::TouchPoint *)jarg1;
29779   arg2 = (Dali::Vector2 *)jarg2;
29780   if (arg1) (arg1)->local = *arg2;
29781 }
29782
29783
29784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29785   void * jresult ;
29786   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29787   Dali::Vector2 *result = 0 ;
29788
29789   arg1 = (Dali::TouchPoint *)jarg1;
29790   result = (Dali::Vector2 *)& ((arg1)->local);
29791   jresult = (void *)result;
29792   return jresult;
29793 }
29794
29795
29796 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29797   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29798   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29799
29800   arg1 = (Dali::TouchPoint *)jarg1;
29801   arg2 = (Dali::Vector2 *)jarg2;
29802   if (arg1) (arg1)->screen = *arg2;
29803 }
29804
29805
29806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29807   void * jresult ;
29808   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29809   Dali::Vector2 *result = 0 ;
29810
29811   arg1 = (Dali::TouchPoint *)jarg1;
29812   result = (Dali::Vector2 *)& ((arg1)->screen);
29813   jresult = (void *)result;
29814   return jresult;
29815 }
29816
29817
29818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29819   void * jresult ;
29820   Dali::TouchData *result = 0 ;
29821
29822   {
29823     try {
29824       result = (Dali::TouchData *)new Dali::TouchData();
29825     } catch (std::out_of_range& e) {
29826       {
29827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29828       };
29829     } catch (std::exception& e) {
29830       {
29831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29832       };
29833     } catch (Dali::DaliException e) {
29834       {
29835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29836       };
29837     } catch (...) {
29838       {
29839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29840       };
29841     }
29842   }
29843
29844   jresult = (void *)result;
29845   return jresult;
29846 }
29847
29848
29849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29850   void * jresult ;
29851   Dali::TouchData *arg1 = 0 ;
29852   Dali::TouchData *result = 0 ;
29853
29854   arg1 = (Dali::TouchData *)jarg1;
29855   if (!arg1) {
29856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29857     return 0;
29858   }
29859   {
29860     try {
29861       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29862     } catch (std::out_of_range& e) {
29863       {
29864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29865       };
29866     } catch (std::exception& e) {
29867       {
29868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29869       };
29870     } catch (Dali::DaliException e) {
29871       {
29872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29873       };
29874     } catch (...) {
29875       {
29876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29877       };
29878     }
29879   }
29880
29881   jresult = (void *)result;
29882   return jresult;
29883 }
29884
29885
29886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29887   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29888
29889   arg1 = (Dali::TouchData *)jarg1;
29890   {
29891     try {
29892       delete arg1;
29893     } catch (std::out_of_range& e) {
29894       {
29895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29896       };
29897     } catch (std::exception& e) {
29898       {
29899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29900       };
29901     } catch (Dali::DaliException e) {
29902       {
29903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29904       };
29905     } catch (...) {
29906       {
29907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29908       };
29909     }
29910   }
29911
29912 }
29913
29914
29915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29916   void * jresult ;
29917   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29918   Dali::TouchData *arg2 = 0 ;
29919   Dali::TouchData *result = 0 ;
29920
29921   arg1 = (Dali::TouchData *)jarg1;
29922   arg2 = (Dali::TouchData *)jarg2;
29923   if (!arg2) {
29924     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29925     return 0;
29926   }
29927   {
29928     try {
29929       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29930     } catch (std::out_of_range& e) {
29931       {
29932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29933       };
29934     } catch (std::exception& e) {
29935       {
29936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29937       };
29938     } catch (Dali::DaliException e) {
29939       {
29940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29941       };
29942     } catch (...) {
29943       {
29944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29945       };
29946     }
29947   }
29948
29949   jresult = (void *)result;
29950   return jresult;
29951 }
29952
29953
29954 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29955   unsigned long jresult ;
29956   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29957   unsigned long result;
29958
29959   arg1 = (Dali::TouchData *)jarg1;
29960   {
29961     try {
29962       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29963     } catch (std::out_of_range& e) {
29964       {
29965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29966       };
29967     } catch (std::exception& e) {
29968       {
29969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29970       };
29971     } catch (Dali::DaliException e) {
29972       {
29973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29974       };
29975     } catch (...) {
29976       {
29977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29978       };
29979     }
29980   }
29981
29982   jresult = (unsigned long)result;
29983   return jresult;
29984 }
29985
29986
29987 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29988   unsigned long jresult ;
29989   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29990   std::size_t result;
29991
29992   arg1 = (Dali::TouchData *)jarg1;
29993   {
29994     try {
29995       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29996     } catch (std::out_of_range& e) {
29997       {
29998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29999       };
30000     } catch (std::exception& e) {
30001       {
30002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30003       };
30004     } catch (Dali::DaliException e) {
30005       {
30006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30007       };
30008     } catch (...) {
30009       {
30010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30011       };
30012     }
30013   }
30014
30015   jresult = (unsigned long)result;
30016   return jresult;
30017 }
30018
30019
30020 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
30021   int jresult ;
30022   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30023   std::size_t arg2 ;
30024   int32_t result;
30025
30026   arg1 = (Dali::TouchData *)jarg1;
30027   arg2 = (std::size_t)jarg2;
30028   {
30029     try {
30030       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
30031     } catch (std::out_of_range& e) {
30032       {
30033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30034       };
30035     } catch (std::exception& e) {
30036       {
30037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30038       };
30039     } catch (Dali::DaliException e) {
30040       {
30041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30042       };
30043     } catch (...) {
30044       {
30045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30046       };
30047     }
30048   }
30049
30050   jresult = result;
30051   return jresult;
30052 }
30053
30054
30055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
30056   int jresult ;
30057   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30058   std::size_t arg2 ;
30059   Dali::PointState::Type result;
30060
30061   arg1 = (Dali::TouchData *)jarg1;
30062   arg2 = (std::size_t)jarg2;
30063   {
30064     try {
30065       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
30066     } catch (std::out_of_range& e) {
30067       {
30068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30069       };
30070     } catch (std::exception& e) {
30071       {
30072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30073       };
30074     } catch (Dali::DaliException e) {
30075       {
30076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30077       };
30078     } catch (...) {
30079       {
30080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30081       };
30082     }
30083   }
30084
30085   jresult = (int)result;
30086   return jresult;
30087 }
30088
30089
30090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
30091   void * jresult ;
30092   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30093   std::size_t arg2 ;
30094   Dali::Actor result;
30095
30096   arg1 = (Dali::TouchData *)jarg1;
30097   arg2 = (std::size_t)jarg2;
30098   {
30099     try {
30100       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
30101     } catch (std::out_of_range& e) {
30102       {
30103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30104       };
30105     } catch (std::exception& e) {
30106       {
30107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30108       };
30109     } catch (Dali::DaliException e) {
30110       {
30111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30112       };
30113     } catch (...) {
30114       {
30115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30116       };
30117     }
30118   }
30119
30120   jresult = new Dali::Actor((const Dali::Actor &)result);
30121   return jresult;
30122 }
30123
30124
30125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
30126   void * jresult ;
30127   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30128   std::size_t arg2 ;
30129   Dali::Vector2 *result = 0 ;
30130
30131   arg1 = (Dali::TouchData *)jarg1;
30132   arg2 = (std::size_t)jarg2;
30133   {
30134     try {
30135       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
30136     } catch (std::out_of_range& e) {
30137       {
30138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30139       };
30140     } catch (std::exception& e) {
30141       {
30142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30143       };
30144     } catch (Dali::DaliException e) {
30145       {
30146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30147       };
30148     } catch (...) {
30149       {
30150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30151       };
30152     }
30153   }
30154
30155   jresult = (void *)result;
30156   return jresult;
30157 }
30158
30159
30160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
30161   void * jresult ;
30162   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30163   std::size_t arg2 ;
30164   Dali::Vector2 *result = 0 ;
30165
30166   arg1 = (Dali::TouchData *)jarg1;
30167   arg2 = (std::size_t)jarg2;
30168   {
30169     try {
30170       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
30171     } catch (std::out_of_range& e) {
30172       {
30173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30174       };
30175     } catch (std::exception& e) {
30176       {
30177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30178       };
30179     } catch (Dali::DaliException e) {
30180       {
30181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30182       };
30183     } catch (...) {
30184       {
30185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30186       };
30187     }
30188   }
30189
30190   jresult = (void *)result;
30191   return jresult;
30192 }
30193
30194
30195 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
30196   float jresult ;
30197   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30198   std::size_t arg2 ;
30199   float result;
30200
30201   arg1 = (Dali::TouchData *)jarg1;
30202   arg2 = (std::size_t)jarg2;
30203   {
30204     try {
30205       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
30206     } catch (std::out_of_range& e) {
30207       {
30208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30209       };
30210     } catch (std::exception& e) {
30211       {
30212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30213       };
30214     } catch (Dali::DaliException e) {
30215       {
30216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30217       };
30218     } catch (...) {
30219       {
30220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30221       };
30222     }
30223   }
30224
30225   jresult = result;
30226   return jresult;
30227 }
30228
30229
30230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
30231   void * jresult ;
30232   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30233   std::size_t arg2 ;
30234   Dali::Vector2 *result = 0 ;
30235
30236   arg1 = (Dali::TouchData *)jarg1;
30237   arg2 = (std::size_t)jarg2;
30238   {
30239     try {
30240       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
30241     } catch (std::out_of_range& e) {
30242       {
30243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30244       };
30245     } catch (std::exception& e) {
30246       {
30247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30248       };
30249     } catch (Dali::DaliException e) {
30250       {
30251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30252       };
30253     } catch (...) {
30254       {
30255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30256       };
30257     }
30258   }
30259
30260   jresult = (void *)result;
30261   return jresult;
30262 }
30263
30264
30265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
30266   float jresult ;
30267   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30268   std::size_t arg2 ;
30269   float result;
30270
30271   arg1 = (Dali::TouchData *)jarg1;
30272   arg2 = (std::size_t)jarg2;
30273   {
30274     try {
30275       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
30276     } catch (std::out_of_range& e) {
30277       {
30278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30279       };
30280     } catch (std::exception& e) {
30281       {
30282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30283       };
30284     } catch (Dali::DaliException e) {
30285       {
30286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30287       };
30288     } catch (...) {
30289       {
30290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30291       };
30292     }
30293   }
30294
30295   jresult = result;
30296   return jresult;
30297 }
30298
30299
30300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
30301   void * jresult ;
30302   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30303   std::size_t arg2 ;
30304   Dali::Degree result;
30305
30306   arg1 = (Dali::TouchData *)jarg1;
30307   arg2 = (std::size_t)jarg2;
30308   {
30309     try {
30310       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
30311     } catch (std::out_of_range& e) {
30312       {
30313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30314       };
30315     } catch (std::exception& e) {
30316       {
30317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30318       };
30319     } catch (Dali::DaliException e) {
30320       {
30321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30322       };
30323     } catch (...) {
30324       {
30325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30326       };
30327     }
30328   }
30329
30330   jresult = new Dali::Degree((const Dali::Degree &)result);
30331   return jresult;
30332 }
30333
30334
30335 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
30336   int jresult ;
30337   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
30338   std::size_t arg2 ;
30339   Dali::MouseButton::Type result;
30340
30341   arg1 = (Dali::TouchData *)jarg1;
30342   arg2 = (std::size_t)jarg2;
30343   {
30344     try {
30345       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
30346     } catch (std::out_of_range& e) {
30347       {
30348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30349       };
30350     } catch (std::exception& e) {
30351       {
30352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30353       };
30354     } catch (Dali::DaliException e) {
30355       {
30356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30357       };
30358     } catch (...) {
30359       {
30360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30361       };
30362     }
30363   }
30364
30365   jresult = static_cast< int >(result);
30366   return jresult;
30367 }
30368
30369
30370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
30371   void * jresult ;
30372   Dali::GestureDetector *result = 0 ;
30373
30374   {
30375     try {
30376       result = (Dali::GestureDetector *)new Dali::GestureDetector();
30377     } catch (std::out_of_range& e) {
30378       {
30379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30380       };
30381     } catch (std::exception& e) {
30382       {
30383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30384       };
30385     } catch (Dali::DaliException e) {
30386       {
30387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30388       };
30389     } catch (...) {
30390       {
30391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30392       };
30393     }
30394   }
30395
30396   jresult = (void *)result;
30397   return jresult;
30398 }
30399
30400
30401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30402   void * jresult ;
30403   Dali::BaseHandle arg1 ;
30404   Dali::BaseHandle *argp1 ;
30405   Dali::GestureDetector result;
30406
30407   argp1 = (Dali::BaseHandle *)jarg1;
30408   if (!argp1) {
30409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30410     return 0;
30411   }
30412   arg1 = *argp1;
30413   {
30414     try {
30415       result = Dali::GestureDetector::DownCast(arg1);
30416     } catch (std::out_of_range& e) {
30417       {
30418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30419       };
30420     } catch (std::exception& e) {
30421       {
30422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30423       };
30424     } catch (Dali::DaliException e) {
30425       {
30426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30427       };
30428     } catch (...) {
30429       {
30430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30431       };
30432     }
30433   }
30434
30435   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30436   return jresult;
30437 }
30438
30439
30440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30441   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30442
30443   arg1 = (Dali::GestureDetector *)jarg1;
30444   {
30445     try {
30446       delete arg1;
30447     } catch (std::out_of_range& e) {
30448       {
30449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30450       };
30451     } catch (std::exception& e) {
30452       {
30453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30454       };
30455     } catch (Dali::DaliException e) {
30456       {
30457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30458       };
30459     } catch (...) {
30460       {
30461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30462       };
30463     }
30464   }
30465
30466 }
30467
30468
30469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30470   void * jresult ;
30471   Dali::GestureDetector *arg1 = 0 ;
30472   Dali::GestureDetector *result = 0 ;
30473
30474   arg1 = (Dali::GestureDetector *)jarg1;
30475   if (!arg1) {
30476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30477     return 0;
30478   }
30479   {
30480     try {
30481       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30482     } catch (std::out_of_range& e) {
30483       {
30484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30485       };
30486     } catch (std::exception& e) {
30487       {
30488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30489       };
30490     } catch (Dali::DaliException e) {
30491       {
30492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30493       };
30494     } catch (...) {
30495       {
30496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30497       };
30498     }
30499   }
30500
30501   jresult = (void *)result;
30502   return jresult;
30503 }
30504
30505
30506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30507   void * jresult ;
30508   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30509   Dali::GestureDetector *arg2 = 0 ;
30510   Dali::GestureDetector *result = 0 ;
30511
30512   arg1 = (Dali::GestureDetector *)jarg1;
30513   arg2 = (Dali::GestureDetector *)jarg2;
30514   if (!arg2) {
30515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30516     return 0;
30517   }
30518   {
30519     try {
30520       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30521     } catch (std::out_of_range& e) {
30522       {
30523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30524       };
30525     } catch (std::exception& e) {
30526       {
30527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30528       };
30529     } catch (Dali::DaliException e) {
30530       {
30531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30532       };
30533     } catch (...) {
30534       {
30535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30536       };
30537     }
30538   }
30539
30540   jresult = (void *)result;
30541   return jresult;
30542 }
30543
30544
30545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30546   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30547   Dali::Actor arg2 ;
30548   Dali::Actor *argp2 ;
30549
30550   arg1 = (Dali::GestureDetector *)jarg1;
30551   argp2 = (Dali::Actor *)jarg2;
30552   if (!argp2) {
30553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30554     return ;
30555   }
30556   arg2 = *argp2;
30557   {
30558     try {
30559       (arg1)->Attach(arg2);
30560     } catch (std::out_of_range& e) {
30561       {
30562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30563       };
30564     } catch (std::exception& e) {
30565       {
30566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30567       };
30568     } catch (Dali::DaliException e) {
30569       {
30570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30571       };
30572     } catch (...) {
30573       {
30574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30575       };
30576     }
30577   }
30578
30579 }
30580
30581
30582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30583   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30584   Dali::Actor arg2 ;
30585   Dali::Actor *argp2 ;
30586
30587   arg1 = (Dali::GestureDetector *)jarg1;
30588   argp2 = (Dali::Actor *)jarg2;
30589   if (!argp2) {
30590     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30591     return ;
30592   }
30593   arg2 = *argp2;
30594   {
30595     try {
30596       (arg1)->Detach(arg2);
30597     } catch (std::out_of_range& e) {
30598       {
30599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30600       };
30601     } catch (std::exception& e) {
30602       {
30603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30604       };
30605     } catch (Dali::DaliException e) {
30606       {
30607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30608       };
30609     } catch (...) {
30610       {
30611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30612       };
30613     }
30614   }
30615
30616 }
30617
30618
30619 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30620   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30621
30622   arg1 = (Dali::GestureDetector *)jarg1;
30623   {
30624     try {
30625       (arg1)->DetachAll();
30626     } catch (std::out_of_range& e) {
30627       {
30628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30629       };
30630     } catch (std::exception& e) {
30631       {
30632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30633       };
30634     } catch (Dali::DaliException e) {
30635       {
30636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30637       };
30638     } catch (...) {
30639       {
30640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30641       };
30642     }
30643   }
30644
30645 }
30646
30647
30648 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30649   unsigned long jresult ;
30650   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30651   size_t result;
30652
30653   arg1 = (Dali::GestureDetector *)jarg1;
30654   {
30655     try {
30656       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30657     } catch (std::out_of_range& e) {
30658       {
30659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30660       };
30661     } catch (std::exception& e) {
30662       {
30663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30664       };
30665     } catch (Dali::DaliException e) {
30666       {
30667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30668       };
30669     } catch (...) {
30670       {
30671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30672       };
30673     }
30674   }
30675
30676   jresult = (unsigned long)result;
30677   return jresult;
30678 }
30679
30680
30681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30682   void * jresult ;
30683   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30684   size_t arg2 ;
30685   Dali::Actor result;
30686
30687   arg1 = (Dali::GestureDetector *)jarg1;
30688   arg2 = (size_t)jarg2;
30689   {
30690     try {
30691       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30692     } catch (std::out_of_range& e) {
30693       {
30694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30695       };
30696     } catch (std::exception& e) {
30697       {
30698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30699       };
30700     } catch (Dali::DaliException e) {
30701       {
30702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30703       };
30704     } catch (...) {
30705       {
30706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30707       };
30708     }
30709   }
30710
30711   jresult = new Dali::Actor((const Dali::Actor &)result);
30712   return jresult;
30713 }
30714
30715
30716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30717   void * jresult ;
30718   Dali::Gesture *arg1 = 0 ;
30719   Dali::Gesture *result = 0 ;
30720
30721   arg1 = (Dali::Gesture *)jarg1;
30722   if (!arg1) {
30723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30724     return 0;
30725   }
30726   {
30727     try {
30728       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30729     } catch (std::out_of_range& e) {
30730       {
30731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30732       };
30733     } catch (std::exception& e) {
30734       {
30735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30736       };
30737     } catch (Dali::DaliException e) {
30738       {
30739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30740       };
30741     } catch (...) {
30742       {
30743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30744       };
30745     }
30746   }
30747
30748   jresult = (void *)result;
30749   return jresult;
30750 }
30751
30752
30753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30754   void * jresult ;
30755   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30756   Dali::Gesture *arg2 = 0 ;
30757   Dali::Gesture *result = 0 ;
30758
30759   arg1 = (Dali::Gesture *)jarg1;
30760   arg2 = (Dali::Gesture *)jarg2;
30761   if (!arg2) {
30762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30763     return 0;
30764   }
30765   {
30766     try {
30767       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30768     } catch (std::out_of_range& e) {
30769       {
30770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30771       };
30772     } catch (std::exception& e) {
30773       {
30774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30775       };
30776     } catch (Dali::DaliException e) {
30777       {
30778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30779       };
30780     } catch (...) {
30781       {
30782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30783       };
30784     }
30785   }
30786
30787   jresult = (void *)result;
30788   return jresult;
30789 }
30790
30791
30792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30793   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30794
30795   arg1 = (Dali::Gesture *)jarg1;
30796   {
30797     try {
30798       delete arg1;
30799     } catch (std::out_of_range& e) {
30800       {
30801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30802       };
30803     } catch (std::exception& e) {
30804       {
30805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30806       };
30807     } catch (Dali::DaliException e) {
30808       {
30809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30810       };
30811     } catch (...) {
30812       {
30813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30814       };
30815     }
30816   }
30817
30818 }
30819
30820
30821 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30822   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30823   Dali::Gesture::Type arg2 ;
30824
30825   arg1 = (Dali::Gesture *)jarg1;
30826   arg2 = (Dali::Gesture::Type)jarg2;
30827   if (arg1) (arg1)->type = arg2;
30828 }
30829
30830
30831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30832   int jresult ;
30833   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30834   Dali::Gesture::Type result;
30835
30836   arg1 = (Dali::Gesture *)jarg1;
30837   result = (Dali::Gesture::Type) ((arg1)->type);
30838   jresult = (int)result;
30839   return jresult;
30840 }
30841
30842
30843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30844   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30845   Dali::Gesture::State arg2 ;
30846
30847   arg1 = (Dali::Gesture *)jarg1;
30848   arg2 = (Dali::Gesture::State)jarg2;
30849   if (arg1) (arg1)->state = arg2;
30850 }
30851
30852
30853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30854   int jresult ;
30855   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30856   Dali::Gesture::State result;
30857
30858   arg1 = (Dali::Gesture *)jarg1;
30859   result = (Dali::Gesture::State) ((arg1)->state);
30860   jresult = (int)result;
30861   return jresult;
30862 }
30863
30864
30865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30866   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30867   unsigned int arg2 ;
30868
30869   arg1 = (Dali::Gesture *)jarg1;
30870   arg2 = (unsigned int)jarg2;
30871   if (arg1) (arg1)->time = arg2;
30872 }
30873
30874
30875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30876   unsigned int jresult ;
30877   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30878   unsigned int result;
30879
30880   arg1 = (Dali::Gesture *)jarg1;
30881   result = (unsigned int) ((arg1)->time);
30882   jresult = result;
30883   return jresult;
30884 }
30885
30886
30887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30888   void * jresult ;
30889   Dali::HoverEvent *result = 0 ;
30890
30891   {
30892     try {
30893       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30894     } catch (std::out_of_range& e) {
30895       {
30896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30897       };
30898     } catch (std::exception& e) {
30899       {
30900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30901       };
30902     } catch (Dali::DaliException e) {
30903       {
30904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30905       };
30906     } catch (...) {
30907       {
30908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30909       };
30910     }
30911   }
30912
30913   jresult = (void *)result;
30914   return jresult;
30915 }
30916
30917
30918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30919   void * jresult ;
30920   unsigned long arg1 ;
30921   Dali::HoverEvent *result = 0 ;
30922
30923   arg1 = (unsigned long)jarg1;
30924   {
30925     try {
30926       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30927     } catch (std::out_of_range& e) {
30928       {
30929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30930       };
30931     } catch (std::exception& e) {
30932       {
30933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30934       };
30935     } catch (Dali::DaliException e) {
30936       {
30937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30938       };
30939     } catch (...) {
30940       {
30941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30942       };
30943     }
30944   }
30945
30946   jresult = (void *)result;
30947   return jresult;
30948 }
30949
30950
30951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30952   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30953
30954   arg1 = (Dali::HoverEvent *)jarg1;
30955   {
30956     try {
30957       delete arg1;
30958     } catch (std::out_of_range& e) {
30959       {
30960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30961       };
30962     } catch (std::exception& e) {
30963       {
30964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30965       };
30966     } catch (Dali::DaliException e) {
30967       {
30968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30969       };
30970     } catch (...) {
30971       {
30972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30973       };
30974     }
30975   }
30976
30977 }
30978
30979
30980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_points_set(void * jarg1, void * jarg2) {
30981   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30982   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30983
30984   arg1 = (Dali::HoverEvent *)jarg1;
30985   arg2 = (Dali::TouchPointContainer *)jarg2;
30986   if (arg1) (arg1)->points = *arg2;
30987 }
30988
30989
30990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30991   void * jresult ;
30992   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30993   Dali::TouchPointContainer *result = 0 ;
30994
30995   arg1 = (Dali::HoverEvent *)jarg1;
30996   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30997   jresult = (void *)result;
30998   return jresult;
30999 }
31000
31001
31002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
31003   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31004   unsigned long arg2 ;
31005
31006   arg1 = (Dali::HoverEvent *)jarg1;
31007   arg2 = (unsigned long)jarg2;
31008   if (arg1) (arg1)->time = arg2;
31009 }
31010
31011
31012 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
31013   unsigned long jresult ;
31014   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31015   unsigned long result;
31016
31017   arg1 = (Dali::HoverEvent *)jarg1;
31018   result = (unsigned long) ((arg1)->time);
31019   jresult = (unsigned long)result;
31020   return jresult;
31021 }
31022
31023
31024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
31025   unsigned int jresult ;
31026   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31027   unsigned int result;
31028
31029   arg1 = (Dali::HoverEvent *)jarg1;
31030   {
31031     try {
31032       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
31033     } catch (std::out_of_range& e) {
31034       {
31035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31036       };
31037     } catch (std::exception& e) {
31038       {
31039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31040       };
31041     } catch (Dali::DaliException e) {
31042       {
31043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31044       };
31045     } catch (...) {
31046       {
31047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31048       };
31049     }
31050   }
31051
31052   jresult = result;
31053   return jresult;
31054 }
31055
31056
31057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
31058   void * jresult ;
31059   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
31060   unsigned int arg2 ;
31061   Dali::TouchPoint *result = 0 ;
31062
31063   arg1 = (Dali::HoverEvent *)jarg1;
31064   arg2 = (unsigned int)jarg2;
31065   {
31066     try {
31067       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
31068     } catch (std::out_of_range& e) {
31069       {
31070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31071       };
31072     } catch (std::exception& e) {
31073       {
31074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31075       };
31076     } catch (Dali::DaliException e) {
31077       {
31078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31079       };
31080     } catch (...) {
31081       {
31082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31083       };
31084     }
31085   }
31086
31087   jresult = (void *)result;
31088   return jresult;
31089 }
31090
31091
31092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
31093   void * jresult ;
31094   Dali::KeyEvent *result = 0 ;
31095
31096   {
31097     try {
31098       result = (Dali::KeyEvent *)new Dali::KeyEvent();
31099     } catch (std::out_of_range& e) {
31100       {
31101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31102       };
31103     } catch (std::exception& e) {
31104       {
31105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31106       };
31107     } catch (Dali::DaliException e) {
31108       {
31109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31110       };
31111     } catch (...) {
31112       {
31113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31114       };
31115     }
31116   }
31117
31118   jresult = (void *)result;
31119   return jresult;
31120 }
31121
31122
31123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
31124   void * jresult ;
31125   std::string *arg1 = 0 ;
31126   std::string *arg2 = 0 ;
31127   int arg3 ;
31128   int arg4 ;
31129   unsigned long arg5 ;
31130   Dali::KeyEvent::State *arg6 = 0 ;
31131   Dali::KeyEvent::State temp6 ;
31132   Dali::KeyEvent *result = 0 ;
31133
31134   if (!jarg1) {
31135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31136     return 0;
31137   }
31138   std::string arg1_str(jarg1);
31139   arg1 = &arg1_str;
31140   if (!jarg2) {
31141     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31142     return 0;
31143   }
31144   std::string arg2_str(jarg2);
31145   arg2 = &arg2_str;
31146   arg3 = (int)jarg3;
31147   arg4 = (int)jarg4;
31148   arg5 = (unsigned long)jarg5;
31149   temp6 = (Dali::KeyEvent::State)jarg6;
31150   arg6 = &temp6;
31151   {
31152     try {
31153       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
31154     } catch (std::out_of_range& e) {
31155       {
31156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31157       };
31158     } catch (std::exception& e) {
31159       {
31160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31161       };
31162     } catch (Dali::DaliException e) {
31163       {
31164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31165       };
31166     } catch (...) {
31167       {
31168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31169       };
31170     }
31171   }
31172
31173   jresult = (void *)result;
31174
31175   //argout typemap for const std::string&
31176
31177
31178   //argout typemap for const std::string&
31179
31180   return jresult;
31181 }
31182
31183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
31184   void * jresult ;
31185   Dali::KeyEvent *arg1 = 0 ;
31186   Dali::KeyEvent *result = 0 ;
31187
31188   arg1 = (Dali::KeyEvent *)jarg1;
31189   if (!arg1) {
31190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31191     return 0;
31192   }
31193   {
31194     try {
31195       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
31196     } catch (std::out_of_range& e) {
31197       {
31198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31199       };
31200     } catch (std::exception& e) {
31201       {
31202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31203       };
31204     } catch (Dali::DaliException e) {
31205       {
31206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31207       };
31208     } catch (...) {
31209       {
31210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31211       };
31212     }
31213   }
31214
31215   jresult = (void *)result;
31216   return jresult;
31217 }
31218
31219
31220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
31221   void * jresult ;
31222   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31223   Dali::KeyEvent *arg2 = 0 ;
31224   Dali::KeyEvent *result = 0 ;
31225
31226   arg1 = (Dali::KeyEvent *)jarg1;
31227   arg2 = (Dali::KeyEvent *)jarg2;
31228   if (!arg2) {
31229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
31230     return 0;
31231   }
31232   {
31233     try {
31234       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
31235     } catch (std::out_of_range& e) {
31236       {
31237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31238       };
31239     } catch (std::exception& e) {
31240       {
31241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31242       };
31243     } catch (Dali::DaliException e) {
31244       {
31245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31246       };
31247     } catch (...) {
31248       {
31249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31250       };
31251     }
31252   }
31253
31254   jresult = (void *)result;
31255   return jresult;
31256 }
31257
31258
31259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
31260   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31261
31262   arg1 = (Dali::KeyEvent *)jarg1;
31263   {
31264     try {
31265       delete arg1;
31266     } catch (std::out_of_range& e) {
31267       {
31268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31269       };
31270     } catch (std::exception& e) {
31271       {
31272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31273       };
31274     } catch (Dali::DaliException e) {
31275       {
31276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31277       };
31278     } catch (...) {
31279       {
31280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31281       };
31282     }
31283   }
31284
31285 }
31286
31287
31288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
31289   unsigned int jresult ;
31290   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31291   bool result;
31292
31293   arg1 = (Dali::KeyEvent *)jarg1;
31294   {
31295     try {
31296       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
31297     } catch (std::out_of_range& e) {
31298       {
31299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31300       };
31301     } catch (std::exception& e) {
31302       {
31303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31304       };
31305     } catch (Dali::DaliException e) {
31306       {
31307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31308       };
31309     } catch (...) {
31310       {
31311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31312       };
31313     }
31314   }
31315
31316   jresult = result;
31317   return jresult;
31318 }
31319
31320
31321 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
31322   unsigned int jresult ;
31323   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31324   bool result;
31325
31326   arg1 = (Dali::KeyEvent *)jarg1;
31327   {
31328     try {
31329       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
31330     } catch (std::out_of_range& e) {
31331       {
31332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31333       };
31334     } catch (std::exception& e) {
31335       {
31336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31337       };
31338     } catch (Dali::DaliException e) {
31339       {
31340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31341       };
31342     } catch (...) {
31343       {
31344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31345       };
31346     }
31347   }
31348
31349   jresult = result;
31350   return jresult;
31351 }
31352
31353
31354 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
31355   unsigned int jresult ;
31356   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31357   bool result;
31358
31359   arg1 = (Dali::KeyEvent *)jarg1;
31360   {
31361     try {
31362       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
31363     } catch (std::out_of_range& e) {
31364       {
31365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31366       };
31367     } catch (std::exception& e) {
31368       {
31369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31370       };
31371     } catch (Dali::DaliException e) {
31372       {
31373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31374       };
31375     } catch (...) {
31376       {
31377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31378       };
31379     }
31380   }
31381
31382   jresult = result;
31383   return jresult;
31384 }
31385
31386
31387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
31388   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31389   std::string *arg2 = 0 ;
31390
31391   arg1 = (Dali::KeyEvent *)jarg1;
31392   if (!jarg2) {
31393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31394     return ;
31395   }
31396   std::string arg2_str(jarg2);
31397   arg2 = &arg2_str;
31398   if (arg1) (arg1)->keyPressedName = *arg2;
31399
31400   //argout typemap for const std::string&
31401
31402 }
31403
31404
31405 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31406   char * jresult ;
31407
31408   if( jarg1 == NULL )
31409   {
31410     jresult = SWIG_csharp_string_callback( "" );
31411   }
31412   else
31413   {
31414     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31415     std::string *result = 0;
31416
31417     arg1 = ( Dali::KeyEvent * )jarg1;
31418     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31419     jresult = SWIG_csharp_string_callback( result->c_str() );
31420   }
31421
31422   return jresult;
31423 }
31424
31425
31426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31427   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31428   std::string *arg2 = 0 ;
31429
31430   arg1 = (Dali::KeyEvent *)jarg1;
31431   if (!jarg2) {
31432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31433     return ;
31434   }
31435   std::string arg2_str(jarg2);
31436   arg2 = &arg2_str;
31437   if (arg1) (arg1)->keyPressed = *arg2;
31438
31439   //argout typemap for const std::string&
31440
31441 }
31442
31443
31444 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31445   char * jresult ;
31446   if( NULL == jarg1 )
31447   {
31448     jresult = SWIG_csharp_string_callback( "" );
31449   }
31450   else
31451   {
31452     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31453     std::string *result = 0;
31454
31455     arg1 = ( Dali::KeyEvent * )jarg1;
31456     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31457     jresult = SWIG_csharp_string_callback( result->c_str() );
31458   }
31459   return jresult;
31460 }
31461
31462
31463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31464   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31465   int arg2 ;
31466
31467   arg1 = (Dali::KeyEvent *)jarg1;
31468   arg2 = (int)jarg2;
31469   if (arg1) (arg1)->keyCode = arg2;
31470 }
31471
31472
31473 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31474   int jresult ;
31475   if( NULL == jarg1 )
31476   {
31477     jresult = -1;
31478   }
31479   else
31480   {
31481     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31482     int result;
31483
31484     arg1 = ( Dali::KeyEvent * )jarg1;
31485     result = (int)( ( arg1 )->keyCode );
31486     jresult = result;
31487   }
31488   return jresult;
31489 }
31490
31491
31492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31493   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31494   int arg2 ;
31495
31496   arg1 = (Dali::KeyEvent *)jarg1;
31497   arg2 = (int)jarg2;
31498   if (arg1) (arg1)->keyModifier = arg2;
31499 }
31500
31501
31502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31503   int jresult ;
31504   if( jarg1 == NULL )
31505   {
31506     jresult = -1;
31507   }
31508   else
31509   {
31510     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31511     int result;
31512
31513     arg1 = ( Dali::KeyEvent * )jarg1;
31514     result = (int)( ( arg1 )->keyModifier );
31515     jresult = result;
31516   }
31517   return jresult;
31518 }
31519
31520
31521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31522   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31523   unsigned long arg2 ;
31524
31525   arg1 = (Dali::KeyEvent *)jarg1;
31526   arg2 = (unsigned long)jarg2;
31527   if (arg1) (arg1)->time = arg2;
31528 }
31529
31530
31531 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31532   unsigned long jresult ;
31533   if( jarg1 == NULL )
31534   {
31535     jresult = 0;
31536   }
31537   else
31538   {
31539     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31540     unsigned long result;
31541
31542     arg1 = ( Dali::KeyEvent * )jarg1;
31543     result = (unsigned long)( ( arg1 )->time );
31544     jresult = (unsigned long)result;
31545   }
31546   return jresult;
31547 }
31548
31549
31550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31551   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31552   Dali::KeyEvent::State arg2 ;
31553
31554   arg1 = (Dali::KeyEvent *)jarg1;
31555   arg2 = (Dali::KeyEvent::State)jarg2;
31556   if (arg1) (arg1)->state = arg2;
31557 }
31558
31559
31560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31561   int jresult ;
31562   if( jarg1 == NULL )
31563   {
31564     jresult = -1;
31565   }
31566   else
31567   {
31568     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31569     Dali::KeyEvent::State result;
31570
31571     arg1 = ( Dali::KeyEvent * )jarg1;
31572     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31573     jresult = (int)result;
31574   }
31575   return jresult;
31576 }
31577
31578 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31579   char * jresult ;
31580   std::string result;
31581   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31582
31583   arg1 = (Dali::KeyEvent *)jarg1;
31584   if (!arg1) {
31585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31586     return 0;
31587   }
31588   {
31589     try {
31590       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31591     } catch (std::out_of_range& e) {
31592       {
31593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31594       };
31595     } catch (std::exception& e) {
31596       {
31597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31598       };
31599     } catch (Dali::DaliException e) {
31600       {
31601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31602       };
31603     } catch (...) {
31604       {
31605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31606       };
31607     }
31608
31609   }
31610
31611   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31612   return jresult;
31613 }
31614
31615
31616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31617   void * jresult ;
31618   Dali::LongPressGestureDetector *result = 0 ;
31619
31620   {
31621     try {
31622       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31623     } catch (std::out_of_range& e) {
31624       {
31625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31626       };
31627     } catch (std::exception& e) {
31628       {
31629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31630       };
31631     } catch (Dali::DaliException e) {
31632       {
31633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31634       };
31635     } catch (...) {
31636       {
31637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31638       };
31639     }
31640   }
31641
31642   jresult = (void *)result;
31643   return jresult;
31644 }
31645
31646
31647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31648   void * jresult ;
31649   Dali::LongPressGestureDetector result;
31650
31651   {
31652     try {
31653       result = Dali::LongPressGestureDetector::New();
31654     } catch (std::out_of_range& e) {
31655       {
31656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31657       };
31658     } catch (std::exception& e) {
31659       {
31660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31661       };
31662     } catch (Dali::DaliException e) {
31663       {
31664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31665       };
31666     } catch (...) {
31667       {
31668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31669       };
31670     }
31671   }
31672
31673   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31674   return jresult;
31675 }
31676
31677
31678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31679   void * jresult ;
31680   unsigned int arg1 ;
31681   Dali::LongPressGestureDetector result;
31682
31683   arg1 = (unsigned int)jarg1;
31684   {
31685     try {
31686       result = Dali::LongPressGestureDetector::New(arg1);
31687     } catch (std::out_of_range& e) {
31688       {
31689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31690       };
31691     } catch (std::exception& e) {
31692       {
31693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31694       };
31695     } catch (Dali::DaliException e) {
31696       {
31697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31698       };
31699     } catch (...) {
31700       {
31701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31702       };
31703     }
31704   }
31705
31706   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31707   return jresult;
31708 }
31709
31710
31711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31712   void * jresult ;
31713   unsigned int arg1 ;
31714   unsigned int arg2 ;
31715   Dali::LongPressGestureDetector result;
31716
31717   arg1 = (unsigned int)jarg1;
31718   arg2 = (unsigned int)jarg2;
31719   {
31720     try {
31721       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31722     } catch (std::out_of_range& e) {
31723       {
31724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31725       };
31726     } catch (std::exception& e) {
31727       {
31728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31729       };
31730     } catch (Dali::DaliException e) {
31731       {
31732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31733       };
31734     } catch (...) {
31735       {
31736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31737       };
31738     }
31739   }
31740
31741   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31742   return jresult;
31743 }
31744
31745
31746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31747   void * jresult ;
31748   Dali::BaseHandle arg1 ;
31749   Dali::BaseHandle *argp1 ;
31750   Dali::LongPressGestureDetector result;
31751
31752   argp1 = (Dali::BaseHandle *)jarg1;
31753   if (!argp1) {
31754     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31755     return 0;
31756   }
31757   arg1 = *argp1;
31758   {
31759     try {
31760       result = Dali::LongPressGestureDetector::DownCast(arg1);
31761     } catch (std::out_of_range& e) {
31762       {
31763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31764       };
31765     } catch (std::exception& e) {
31766       {
31767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31768       };
31769     } catch (Dali::DaliException e) {
31770       {
31771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31772       };
31773     } catch (...) {
31774       {
31775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31776       };
31777     }
31778   }
31779
31780   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31781   return jresult;
31782 }
31783
31784
31785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31786   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31787
31788   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31789   {
31790     try {
31791       delete arg1;
31792     } catch (std::out_of_range& e) {
31793       {
31794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31795       };
31796     } catch (std::exception& e) {
31797       {
31798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31799       };
31800     } catch (Dali::DaliException e) {
31801       {
31802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31803       };
31804     } catch (...) {
31805       {
31806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31807       };
31808     }
31809   }
31810
31811 }
31812
31813
31814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31815   void * jresult ;
31816   Dali::LongPressGestureDetector *arg1 = 0 ;
31817   Dali::LongPressGestureDetector *result = 0 ;
31818
31819   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31820   if (!arg1) {
31821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31822     return 0;
31823   }
31824   {
31825     try {
31826       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31827     } catch (std::out_of_range& e) {
31828       {
31829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31830       };
31831     } catch (std::exception& e) {
31832       {
31833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31834       };
31835     } catch (Dali::DaliException e) {
31836       {
31837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31838       };
31839     } catch (...) {
31840       {
31841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31842       };
31843     }
31844   }
31845
31846   jresult = (void *)result;
31847   return jresult;
31848 }
31849
31850
31851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31852   void * jresult ;
31853   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31854   Dali::LongPressGestureDetector *arg2 = 0 ;
31855   Dali::LongPressGestureDetector *result = 0 ;
31856
31857   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31858   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31859   if (!arg2) {
31860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31861     return 0;
31862   }
31863   {
31864     try {
31865       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31866     } catch (std::out_of_range& e) {
31867       {
31868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31869       };
31870     } catch (std::exception& e) {
31871       {
31872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31873       };
31874     } catch (Dali::DaliException e) {
31875       {
31876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31877       };
31878     } catch (...) {
31879       {
31880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31881       };
31882     }
31883   }
31884
31885   jresult = (void *)result;
31886   return jresult;
31887 }
31888
31889
31890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31891   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31892   unsigned int arg2 ;
31893
31894   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31895   arg2 = (unsigned int)jarg2;
31896   {
31897     try {
31898       (arg1)->SetTouchesRequired(arg2);
31899     } catch (std::out_of_range& e) {
31900       {
31901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31902       };
31903     } catch (std::exception& e) {
31904       {
31905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31906       };
31907     } catch (Dali::DaliException e) {
31908       {
31909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31910       };
31911     } catch (...) {
31912       {
31913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31914       };
31915     }
31916   }
31917
31918 }
31919
31920
31921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31922   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31923   unsigned int arg2 ;
31924   unsigned int arg3 ;
31925
31926   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31927   arg2 = (unsigned int)jarg2;
31928   arg3 = (unsigned int)jarg3;
31929   {
31930     try {
31931       (arg1)->SetTouchesRequired(arg2,arg3);
31932     } catch (std::out_of_range& e) {
31933       {
31934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31935       };
31936     } catch (std::exception& e) {
31937       {
31938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31939       };
31940     } catch (Dali::DaliException e) {
31941       {
31942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31943       };
31944     } catch (...) {
31945       {
31946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31947       };
31948     }
31949   }
31950
31951 }
31952
31953
31954 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31955   unsigned int jresult ;
31956   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31957   unsigned int result;
31958
31959   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31960   {
31961     try {
31962       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31963     } catch (std::out_of_range& e) {
31964       {
31965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31966       };
31967     } catch (std::exception& e) {
31968       {
31969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31970       };
31971     } catch (Dali::DaliException e) {
31972       {
31973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31974       };
31975     } catch (...) {
31976       {
31977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31978       };
31979     }
31980   }
31981
31982   jresult = result;
31983   return jresult;
31984 }
31985
31986
31987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31988   unsigned int jresult ;
31989   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31990   unsigned int result;
31991
31992   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31993   {
31994     try {
31995       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31996     } catch (std::out_of_range& e) {
31997       {
31998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31999       };
32000     } catch (std::exception& e) {
32001       {
32002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32003       };
32004     } catch (Dali::DaliException e) {
32005       {
32006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32007       };
32008     } catch (...) {
32009       {
32010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32011       };
32012     }
32013   }
32014
32015   jresult = result;
32016   return jresult;
32017 }
32018
32019
32020 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
32021   void * jresult ;
32022   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
32023   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
32024
32025   arg1 = (Dali::LongPressGestureDetector *)jarg1;
32026   {
32027     try {
32028       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
32029     } catch (std::out_of_range& e) {
32030       {
32031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32032       };
32033     } catch (std::exception& e) {
32034       {
32035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32036       };
32037     } catch (Dali::DaliException e) {
32038       {
32039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32040       };
32041     } catch (...) {
32042       {
32043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32044       };
32045     }
32046   }
32047
32048   jresult = (void *)result;
32049   return jresult;
32050 }
32051
32052
32053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
32054   void * jresult ;
32055   Dali::Gesture::State arg1 ;
32056   Dali::LongPressGesture *result = 0 ;
32057
32058   arg1 = (Dali::Gesture::State)jarg1;
32059   {
32060     try {
32061       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
32062     } catch (std::out_of_range& e) {
32063       {
32064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32065       };
32066     } catch (std::exception& e) {
32067       {
32068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32069       };
32070     } catch (Dali::DaliException e) {
32071       {
32072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32073       };
32074     } catch (...) {
32075       {
32076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32077       };
32078     }
32079   }
32080
32081   jresult = (void *)result;
32082   return jresult;
32083 }
32084
32085
32086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
32087   void * jresult ;
32088   Dali::LongPressGesture *arg1 = 0 ;
32089   Dali::LongPressGesture *result = 0 ;
32090
32091   arg1 = (Dali::LongPressGesture *)jarg1;
32092   if (!arg1) {
32093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32094     return 0;
32095   }
32096   {
32097     try {
32098       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
32099     } catch (std::out_of_range& e) {
32100       {
32101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32102       };
32103     } catch (std::exception& e) {
32104       {
32105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32106       };
32107     } catch (Dali::DaliException e) {
32108       {
32109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32110       };
32111     } catch (...) {
32112       {
32113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32114       };
32115     }
32116   }
32117
32118   jresult = (void *)result;
32119   return jresult;
32120 }
32121
32122
32123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
32124   void * jresult ;
32125   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32126   Dali::LongPressGesture *arg2 = 0 ;
32127   Dali::LongPressGesture *result = 0 ;
32128
32129   arg1 = (Dali::LongPressGesture *)jarg1;
32130   arg2 = (Dali::LongPressGesture *)jarg2;
32131   if (!arg2) {
32132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
32133     return 0;
32134   }
32135   {
32136     try {
32137       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
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 (Dali::DaliException e) {
32147       {
32148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32149       };
32150     } catch (...) {
32151       {
32152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32153       };
32154     }
32155   }
32156
32157   jresult = (void *)result;
32158   return jresult;
32159 }
32160
32161
32162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
32163   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32164
32165   arg1 = (Dali::LongPressGesture *)jarg1;
32166   {
32167     try {
32168       delete arg1;
32169     } catch (std::out_of_range& e) {
32170       {
32171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32172       };
32173     } catch (std::exception& e) {
32174       {
32175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32176       };
32177     } catch (Dali::DaliException e) {
32178       {
32179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32180       };
32181     } catch (...) {
32182       {
32183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32184       };
32185     }
32186   }
32187
32188 }
32189
32190
32191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
32192   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32193   unsigned int arg2 ;
32194
32195   arg1 = (Dali::LongPressGesture *)jarg1;
32196   arg2 = (unsigned int)jarg2;
32197   if (arg1) (arg1)->numberOfTouches = arg2;
32198 }
32199
32200
32201 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
32202   unsigned int jresult ;
32203   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32204   unsigned int result;
32205
32206   arg1 = (Dali::LongPressGesture *)jarg1;
32207   result = (unsigned int) ((arg1)->numberOfTouches);
32208   jresult = result;
32209   return jresult;
32210 }
32211
32212
32213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
32214   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32215   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32216
32217   arg1 = (Dali::LongPressGesture *)jarg1;
32218   arg2 = (Dali::Vector2 *)jarg2;
32219   if (arg1) (arg1)->screenPoint = *arg2;
32220 }
32221
32222
32223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
32224   void * jresult ;
32225   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32226   Dali::Vector2 *result = 0 ;
32227
32228   arg1 = (Dali::LongPressGesture *)jarg1;
32229   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
32230   jresult = (void *)result;
32231   return jresult;
32232 }
32233
32234
32235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
32236   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32237   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32238
32239   arg1 = (Dali::LongPressGesture *)jarg1;
32240   arg2 = (Dali::Vector2 *)jarg2;
32241   if (arg1) (arg1)->localPoint = *arg2;
32242 }
32243
32244
32245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
32246   void * jresult ;
32247   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
32248   Dali::Vector2 *result = 0 ;
32249
32250   arg1 = (Dali::LongPressGesture *)jarg1;
32251   result = (Dali::Vector2 *)& ((arg1)->localPoint);
32252   jresult = (void *)result;
32253   return jresult;
32254 }
32255
32256
32257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
32258   void * jresult ;
32259   Dali::WheelEvent *result = 0 ;
32260
32261   {
32262     try {
32263       result = (Dali::WheelEvent *)new Dali::WheelEvent();
32264     } catch (std::out_of_range& e) {
32265       {
32266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32267       };
32268     } catch (std::exception& e) {
32269       {
32270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32271       };
32272     } catch (Dali::DaliException e) {
32273       {
32274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32275       };
32276     } catch (...) {
32277       {
32278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32279       };
32280     }
32281   }
32282
32283   jresult = (void *)result;
32284   return jresult;
32285 }
32286
32287
32288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
32289   void * jresult ;
32290   Dali::WheelEvent::Type arg1 ;
32291   int arg2 ;
32292   unsigned int arg3 ;
32293   Dali::Vector2 arg4 ;
32294   int arg5 ;
32295   unsigned int arg6 ;
32296   Dali::Vector2 *argp4 ;
32297   Dali::WheelEvent *result = 0 ;
32298
32299   arg1 = (Dali::WheelEvent::Type)jarg1;
32300   arg2 = (int)jarg2;
32301   arg3 = (unsigned int)jarg3;
32302   argp4 = (Dali::Vector2 *)jarg4;
32303   if (!argp4) {
32304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
32305     return 0;
32306   }
32307   arg4 = *argp4;
32308   arg5 = (int)jarg5;
32309   arg6 = (unsigned int)jarg6;
32310   {
32311     try {
32312       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
32313     } catch (std::out_of_range& e) {
32314       {
32315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32316       };
32317     } catch (std::exception& e) {
32318       {
32319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32320       };
32321     } catch (Dali::DaliException e) {
32322       {
32323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32324       };
32325     } catch (...) {
32326       {
32327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32328       };
32329     }
32330   }
32331
32332   jresult = (void *)result;
32333   return jresult;
32334 }
32335
32336
32337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
32338   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32339
32340   arg1 = (Dali::WheelEvent *)jarg1;
32341   {
32342     try {
32343       delete arg1;
32344     } catch (std::out_of_range& e) {
32345       {
32346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32347       };
32348     } catch (std::exception& e) {
32349       {
32350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32351       };
32352     } catch (Dali::DaliException e) {
32353       {
32354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32355       };
32356     } catch (...) {
32357       {
32358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32359       };
32360     }
32361   }
32362
32363 }
32364
32365
32366 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
32367   unsigned int jresult ;
32368   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32369   bool result;
32370
32371   arg1 = (Dali::WheelEvent *)jarg1;
32372   {
32373     try {
32374       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
32375     } catch (std::out_of_range& e) {
32376       {
32377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32378       };
32379     } catch (std::exception& e) {
32380       {
32381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32382       };
32383     } catch (Dali::DaliException e) {
32384       {
32385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32386       };
32387     } catch (...) {
32388       {
32389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32390       };
32391     }
32392   }
32393
32394   jresult = result;
32395   return jresult;
32396 }
32397
32398
32399 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32400   unsigned int jresult ;
32401   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32402   bool result;
32403
32404   arg1 = (Dali::WheelEvent *)jarg1;
32405   {
32406     try {
32407       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32408     } catch (std::out_of_range& e) {
32409       {
32410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32411       };
32412     } catch (std::exception& e) {
32413       {
32414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32415       };
32416     } catch (Dali::DaliException e) {
32417       {
32418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32419       };
32420     } catch (...) {
32421       {
32422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32423       };
32424     }
32425   }
32426
32427   jresult = result;
32428   return jresult;
32429 }
32430
32431
32432 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32433   unsigned int jresult ;
32434   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32435   bool result;
32436
32437   arg1 = (Dali::WheelEvent *)jarg1;
32438   {
32439     try {
32440       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32441     } catch (std::out_of_range& e) {
32442       {
32443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32444       };
32445     } catch (std::exception& e) {
32446       {
32447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32448       };
32449     } catch (Dali::DaliException e) {
32450       {
32451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32452       };
32453     } catch (...) {
32454       {
32455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32456       };
32457     }
32458   }
32459
32460   jresult = result;
32461   return jresult;
32462 }
32463
32464
32465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32466   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32467   Dali::WheelEvent::Type arg2 ;
32468
32469   arg1 = (Dali::WheelEvent *)jarg1;
32470   arg2 = (Dali::WheelEvent::Type)jarg2;
32471   if (arg1) (arg1)->type = arg2;
32472 }
32473
32474
32475 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32476   int jresult ;
32477   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32478   Dali::WheelEvent::Type result;
32479
32480   arg1 = (Dali::WheelEvent *)jarg1;
32481   result = (Dali::WheelEvent::Type) ((arg1)->type);
32482   jresult = (int)result;
32483   return jresult;
32484 }
32485
32486
32487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32488   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32489   int arg2 ;
32490
32491   arg1 = (Dali::WheelEvent *)jarg1;
32492   arg2 = (int)jarg2;
32493   if (arg1) (arg1)->direction = arg2;
32494 }
32495
32496
32497 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32498   int jresult ;
32499   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32500   int result;
32501
32502   arg1 = (Dali::WheelEvent *)jarg1;
32503   result = (int) ((arg1)->direction);
32504   jresult = result;
32505   return jresult;
32506 }
32507
32508
32509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32510   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32511   unsigned int arg2 ;
32512
32513   arg1 = (Dali::WheelEvent *)jarg1;
32514   arg2 = (unsigned int)jarg2;
32515   if (arg1) (arg1)->modifiers = arg2;
32516 }
32517
32518
32519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32520   unsigned int jresult ;
32521   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32522   unsigned int result;
32523
32524   arg1 = (Dali::WheelEvent *)jarg1;
32525   result = (unsigned int) ((arg1)->modifiers);
32526   jresult = result;
32527   return jresult;
32528 }
32529
32530
32531 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32532   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32533   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32534
32535   arg1 = (Dali::WheelEvent *)jarg1;
32536   arg2 = (Dali::Vector2 *)jarg2;
32537   if (arg1) (arg1)->point = *arg2;
32538 }
32539
32540
32541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32542   void * jresult ;
32543   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32544   Dali::Vector2 *result = 0 ;
32545
32546   arg1 = (Dali::WheelEvent *)jarg1;
32547   result = (Dali::Vector2 *)& ((arg1)->point);
32548   jresult = (void *)result;
32549   return jresult;
32550 }
32551
32552
32553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32554   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32555   int arg2 ;
32556
32557   arg1 = (Dali::WheelEvent *)jarg1;
32558   arg2 = (int)jarg2;
32559   if (arg1) (arg1)->z = arg2;
32560 }
32561
32562
32563 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32564   int jresult ;
32565   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32566   int result;
32567
32568   arg1 = (Dali::WheelEvent *)jarg1;
32569   result = (int) ((arg1)->z);
32570   jresult = result;
32571   return jresult;
32572 }
32573
32574
32575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32576   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32577   unsigned int arg2 ;
32578
32579   arg1 = (Dali::WheelEvent *)jarg1;
32580   arg2 = (unsigned int)jarg2;
32581   if (arg1) (arg1)->timeStamp = arg2;
32582 }
32583
32584
32585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32586   unsigned int jresult ;
32587   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32588   unsigned int result;
32589
32590   arg1 = (Dali::WheelEvent *)jarg1;
32591   result = (unsigned int) ((arg1)->timeStamp);
32592   jresult = result;
32593   return jresult;
32594 }
32595
32596 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32597   char * jresult ;
32598   Dali::KeyEvent *arg1 = 0 ;
32599   std::string result;
32600
32601   arg1 = (Dali::KeyEvent *)jarg1;
32602   if (!arg1) {
32603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32604     return 0;
32605   }
32606   {
32607     try {
32608       result = arg1->GetDeviceName();
32609     } catch (std::out_of_range& e) {
32610       {
32611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32612       };
32613     } catch (std::exception& e) {
32614       {
32615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32616       };
32617     } catch (Dali::DaliException e) {
32618       {
32619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32620       };
32621     } catch (...) {
32622       {
32623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32624       };
32625     }
32626   }
32627
32628   jresult = SWIG_csharp_string_callback((&result)->c_str());
32629   return jresult;
32630 }
32631
32632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32633   int jresult ;
32634   Dali::KeyEvent *arg1 = 0 ;
32635   Dali::Device::Class::Type result;
32636
32637   arg1 = (Dali::KeyEvent *)jarg1;
32638   if (!arg1) {
32639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32640     return 0;
32641   }
32642   {
32643     try {
32644       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32645     } catch (std::out_of_range& e) {
32646       {
32647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32648       };
32649     } catch (std::exception& e) {
32650       {
32651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32652       };
32653     } catch (Dali::DaliException e) {
32654       {
32655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32656       };
32657     } catch (...) {
32658       {
32659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32660       };
32661     }
32662   }
32663
32664   jresult = (int)result;
32665   return jresult;
32666 }
32667
32668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32669   int jresult ;
32670   Dali::KeyEvent *arg1 = 0 ;
32671   Dali::Device::Subclass::Type result;
32672
32673   arg1 = (Dali::KeyEvent *)jarg1;
32674   if (!arg1) {
32675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32676     return 0;
32677   }
32678   {
32679     try {
32680       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32681     } catch (std::out_of_range& e) {
32682       {
32683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32684       };
32685     } catch (std::exception& e) {
32686       {
32687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32688       };
32689     } catch (Dali::DaliException e) {
32690       {
32691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32692       };
32693     } catch (...) {
32694       {
32695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32696       };
32697     }
32698   }
32699
32700   jresult = (int)result;
32701   return jresult;
32702 }
32703
32704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32705   Dali::Actor arg1 ;
32706   Dali::Actor *argp1 ;
32707
32708   argp1 = (Dali::Actor *)jarg1;
32709   if (!argp1) {
32710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32711     return ;
32712   }
32713   arg1 = *argp1;
32714   {
32715     try {
32716       arg1.Raise();
32717     } catch (std::out_of_range& e) {
32718       {
32719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32720       };
32721     } catch (std::exception& e) {
32722       {
32723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32724       };
32725     } catch (Dali::DaliException e) {
32726       {
32727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32728       };
32729     } catch (...) {
32730       {
32731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32732       };
32733     }
32734   }
32735
32736 }
32737
32738
32739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32740   Dali::Actor arg1 ;
32741   Dali::Actor *argp1 ;
32742
32743   argp1 = (Dali::Actor *)jarg1;
32744   if (!argp1) {
32745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32746     return ;
32747   }
32748   arg1 = *argp1;
32749   {
32750     try {
32751       arg1.Lower();
32752     } catch (std::out_of_range& e) {
32753       {
32754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32755       };
32756     } catch (std::exception& e) {
32757       {
32758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32759       };
32760     } catch (Dali::DaliException e) {
32761       {
32762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32763       };
32764     } catch (...) {
32765       {
32766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32767       };
32768     }
32769   }
32770
32771 }
32772
32773
32774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32775   Dali::Actor arg1 ;
32776   Dali::Actor *argp1 ;
32777
32778   argp1 = (Dali::Actor *)jarg1;
32779   if (!argp1) {
32780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32781     return ;
32782   }
32783   arg1 = *argp1;
32784   {
32785     try {
32786       arg1.RaiseToTop();
32787     } catch (std::out_of_range& e) {
32788       {
32789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32790       };
32791     } catch (std::exception& e) {
32792       {
32793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32794       };
32795     } catch (Dali::DaliException e) {
32796       {
32797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32798       };
32799     } catch (...) {
32800       {
32801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32802       };
32803     }
32804   }
32805
32806 }
32807
32808
32809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32810   Dali::Actor arg1 ;
32811   Dali::Actor *argp1 ;
32812
32813   argp1 = (Dali::Actor *)jarg1;
32814   if (!argp1) {
32815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32816     return ;
32817   }
32818   arg1 = *argp1;
32819   {
32820     try {
32821       arg1.LowerToBottom();
32822     } catch (std::out_of_range& e) {
32823       {
32824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32825       };
32826     } catch (std::exception& e) {
32827       {
32828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32829       };
32830     } catch (Dali::DaliException e) {
32831       {
32832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32833       };
32834     } catch (...) {
32835       {
32836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32837       };
32838     }
32839   }
32840
32841 }
32842
32843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32844   Dali::Actor arg1 ;
32845   Dali::Actor arg2 ;
32846   Dali::Actor *argp1 ;
32847   Dali::Actor *argp2 ;
32848
32849   argp1 = (Dali::Actor *)jarg1;
32850   if (!argp1) {
32851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32852     return ;
32853   }
32854   arg1 = *argp1;
32855   argp2 = (Dali::Actor *)jarg2;
32856   if (!argp2) {
32857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32858     return ;
32859   }
32860   arg2 = *argp2;
32861   {
32862     try {
32863       arg1.RaiseAbove(arg2);
32864     } catch (std::out_of_range& e) {
32865       {
32866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32867       };
32868     } catch (std::exception& e) {
32869       {
32870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32871       };
32872     } catch (Dali::DaliException e) {
32873       {
32874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32875       };
32876     } catch (...) {
32877       {
32878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32879       };
32880     }
32881   }
32882
32883 }
32884
32885
32886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32887   Dali::Actor arg1 ;
32888   Dali::Actor arg2 ;
32889   Dali::Actor *argp1 ;
32890   Dali::Actor *argp2 ;
32891
32892   argp1 = (Dali::Actor *)jarg1;
32893   if (!argp1) {
32894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32895     return ;
32896   }
32897   arg1 = *argp1;
32898   argp2 = (Dali::Actor *)jarg2;
32899   if (!argp2) {
32900     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32901     return ;
32902   }
32903   arg2 = *argp2;
32904   {
32905     try {
32906       arg1.LowerBelow(arg2);
32907     } catch (std::out_of_range& e) {
32908       {
32909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32910       };
32911     } catch (std::exception& e) {
32912       {
32913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32914       };
32915     } catch (Dali::DaliException e) {
32916       {
32917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32918       };
32919     } catch (...) {
32920       {
32921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32922       };
32923     }
32924   }
32925
32926 }
32927
32928
32929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32930   void * jresult ;
32931   Dali::Actor arg1 ;
32932   Dali::Actor *argp1 ;
32933   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32934
32935   argp1 = (Dali::Actor *)jarg1;
32936   if (!argp1) {
32937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32938     return 0;
32939   }
32940   arg1 = *argp1;
32941   {
32942     try {
32943       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32944     } catch (std::out_of_range& e) {
32945       {
32946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32947       };
32948     } catch (std::exception& e) {
32949       {
32950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32951       };
32952     } catch (Dali::DaliException e) {
32953       {
32954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32955       };
32956     } catch (...) {
32957       {
32958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32959       };
32960     }
32961   }
32962
32963   jresult = (void *)result;
32964   return jresult;
32965 }
32966
32967
32968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32969   void * jresult ;
32970   Dali::Actor *arg1 ;
32971   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32972
32973   arg1 = (Dali::Actor *)jarg1;
32974   {
32975     try {
32976       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32977     } catch (std::out_of_range& e) {
32978       {
32979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32980       };
32981     } catch (std::exception& e) {
32982       {
32983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32984       };
32985     } catch (Dali::DaliException e) {
32986       {
32987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32988       };
32989     } catch (...) {
32990       {
32991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32992       };
32993     }
32994   }
32995
32996   jresult = (void *)result;
32997   return jresult;
32998 }
32999
33000
33001 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
33002   int jresult ;
33003   int result;
33004
33005   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
33006   jresult = (int)result;
33007   return jresult;
33008 }
33009
33010
33011 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
33012   int jresult ;
33013   int result;
33014
33015   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
33016   jresult = (int)result;
33017   return jresult;
33018 }
33019
33020
33021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
33022   int jresult ;
33023   int result;
33024
33025   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
33026   jresult = (int)result;
33027   return jresult;
33028 }
33029
33030
33031 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
33032   int jresult ;
33033   int result;
33034
33035   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
33036   jresult = (int)result;
33037   return jresult;
33038 }
33039
33040
33041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
33042   int jresult ;
33043   int result;
33044
33045   result = (int)Dali::Actor::Property::ANCHOR_POINT;
33046   jresult = (int)result;
33047   return jresult;
33048 }
33049
33050
33051 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
33052   int jresult ;
33053   int result;
33054
33055   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
33056   jresult = (int)result;
33057   return jresult;
33058 }
33059
33060
33061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
33062   int jresult ;
33063   int result;
33064
33065   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
33066   jresult = (int)result;
33067   return jresult;
33068 }
33069
33070
33071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
33072   int jresult ;
33073   int result;
33074
33075   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
33076   jresult = (int)result;
33077   return jresult;
33078 }
33079
33080
33081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
33082   int jresult ;
33083   int result;
33084
33085   result = (int)Dali::Actor::Property::SIZE;
33086   jresult = (int)result;
33087   return jresult;
33088 }
33089
33090
33091 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
33092   int jresult ;
33093   int result;
33094
33095   result = (int)Dali::Actor::Property::SIZE_WIDTH;
33096   jresult = (int)result;
33097   return jresult;
33098 }
33099
33100
33101 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
33102   int jresult ;
33103   int result;
33104
33105   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
33106   jresult = (int)result;
33107   return jresult;
33108 }
33109
33110
33111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
33112   int jresult ;
33113   int result;
33114
33115   result = (int)Dali::Actor::Property::SIZE_DEPTH;
33116   jresult = (int)result;
33117   return jresult;
33118 }
33119
33120
33121 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
33122   int jresult ;
33123   int result;
33124
33125   result = (int)Dali::Actor::Property::POSITION;
33126   jresult = (int)result;
33127   return jresult;
33128 }
33129
33130
33131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
33132   int jresult ;
33133   int result;
33134
33135   result = (int)Dali::Actor::Property::POSITION_X;
33136   jresult = (int)result;
33137   return jresult;
33138 }
33139
33140
33141 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
33142   int jresult ;
33143   int result;
33144
33145   result = (int)Dali::Actor::Property::POSITION_Y;
33146   jresult = (int)result;
33147   return jresult;
33148 }
33149
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
33152   int jresult ;
33153   int result;
33154
33155   result = (int)Dali::Actor::Property::POSITION_Z;
33156   jresult = (int)result;
33157   return jresult;
33158 }
33159
33160
33161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
33162   int jresult ;
33163   int result;
33164
33165   result = (int)Dali::Actor::Property::WORLD_POSITION;
33166   jresult = (int)result;
33167   return jresult;
33168 }
33169
33170
33171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
33172   int jresult ;
33173   int result;
33174
33175   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
33176   jresult = (int)result;
33177   return jresult;
33178 }
33179
33180
33181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
33182   int jresult ;
33183   int result;
33184
33185   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
33186   jresult = (int)result;
33187   return jresult;
33188 }
33189
33190
33191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
33192   int jresult ;
33193   int result;
33194
33195   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
33196   jresult = (int)result;
33197   return jresult;
33198 }
33199
33200
33201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
33202   int jresult ;
33203   int result;
33204
33205   result = (int)Dali::Actor::Property::ORIENTATION;
33206   jresult = (int)result;
33207   return jresult;
33208 }
33209
33210
33211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
33212   int jresult ;
33213   int result;
33214
33215   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
33216   jresult = (int)result;
33217   return jresult;
33218 }
33219
33220
33221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
33222   int jresult ;
33223   int result;
33224
33225   result = (int)Dali::Actor::Property::SCALE;
33226   jresult = (int)result;
33227   return jresult;
33228 }
33229
33230
33231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
33232   int jresult ;
33233   int result;
33234
33235   result = (int)Dali::Actor::Property::SCALE_X;
33236   jresult = (int)result;
33237   return jresult;
33238 }
33239
33240
33241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
33242   int jresult ;
33243   int result;
33244
33245   result = (int)Dali::Actor::Property::SCALE_Y;
33246   jresult = (int)result;
33247   return jresult;
33248 }
33249
33250
33251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
33252   int jresult ;
33253   int result;
33254
33255   result = (int)Dali::Actor::Property::SCALE_Z;
33256   jresult = (int)result;
33257   return jresult;
33258 }
33259
33260
33261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
33262   int jresult ;
33263   int result;
33264
33265   result = (int)Dali::Actor::Property::WORLD_SCALE;
33266   jresult = (int)result;
33267   return jresult;
33268 }
33269
33270
33271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
33272   int jresult ;
33273   int result;
33274
33275   result = (int)Dali::Actor::Property::VISIBLE;
33276   jresult = (int)result;
33277   return jresult;
33278 }
33279
33280
33281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
33282   int jresult ;
33283   int result;
33284
33285   result = (int)Dali::Actor::Property::COLOR;
33286   jresult = (int)result;
33287   return jresult;
33288 }
33289
33290
33291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
33292   int jresult ;
33293   int result;
33294
33295   result = (int)Dali::Actor::Property::COLOR_RED;
33296   jresult = (int)result;
33297   return jresult;
33298 }
33299
33300
33301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
33302   int jresult ;
33303   int result;
33304
33305   result = (int)Dali::Actor::Property::COLOR_GREEN;
33306   jresult = (int)result;
33307   return jresult;
33308 }
33309
33310
33311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
33312   int jresult ;
33313   int result;
33314
33315   result = (int)Dali::Actor::Property::COLOR_BLUE;
33316   jresult = (int)result;
33317   return jresult;
33318 }
33319
33320
33321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
33322   int jresult ;
33323   int result;
33324
33325   result = (int)Dali::Actor::Property::COLOR_ALPHA;
33326   jresult = (int)result;
33327   return jresult;
33328 }
33329
33330
33331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
33332   int jresult ;
33333   int result;
33334
33335   result = (int)Dali::Actor::Property::WORLD_COLOR;
33336   jresult = (int)result;
33337   return jresult;
33338 }
33339
33340
33341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
33342   int jresult ;
33343   int result;
33344
33345   result = (int)Dali::Actor::Property::WORLD_MATRIX;
33346   jresult = (int)result;
33347   return jresult;
33348 }
33349
33350
33351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
33352   int jresult ;
33353   int result;
33354
33355   result = (int)Dali::Actor::Property::NAME;
33356   jresult = (int)result;
33357   return jresult;
33358 }
33359
33360
33361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
33362   int jresult ;
33363   int result;
33364
33365   result = (int)Dali::Actor::Property::SENSITIVE;
33366   jresult = (int)result;
33367   return jresult;
33368 }
33369
33370
33371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
33372   int jresult ;
33373   int result;
33374
33375   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
33376   jresult = (int)result;
33377   return jresult;
33378 }
33379
33380
33381 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
33382   int jresult ;
33383   int result;
33384
33385   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
33386   jresult = (int)result;
33387   return jresult;
33388 }
33389
33390
33391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
33392   int jresult ;
33393   int result;
33394
33395   result = (int)Dali::Actor::Property::INHERIT_SCALE;
33396   jresult = (int)result;
33397   return jresult;
33398 }
33399
33400
33401 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33402   int jresult ;
33403   int result;
33404
33405   result = (int)Dali::Actor::Property::COLOR_MODE;
33406   jresult = (int)result;
33407   return jresult;
33408 }
33409
33410
33411 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33412   int jresult ;
33413   int result;
33414
33415   result = (int)Dali::Actor::Property::DRAW_MODE;
33416   jresult = (int)result;
33417   return jresult;
33418 }
33419
33420
33421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33422   int jresult ;
33423   int result;
33424
33425   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33426   jresult = (int)result;
33427   return jresult;
33428 }
33429
33430
33431 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33432   int jresult ;
33433   int result;
33434
33435   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33436   jresult = (int)result;
33437   return jresult;
33438 }
33439
33440
33441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33442   int jresult ;
33443   int result;
33444
33445   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33446   jresult = (int)result;
33447   return jresult;
33448 }
33449
33450
33451 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33452   int jresult ;
33453   int result;
33454
33455   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33456   jresult = (int)result;
33457   return jresult;
33458 }
33459
33460
33461 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33462   int jresult ;
33463   int result;
33464
33465   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33466   jresult = (int)result;
33467   return jresult;
33468 }
33469
33470
33471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33472   int jresult ;
33473   int result;
33474
33475   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33476   jresult = (int)result;
33477   return jresult;
33478 }
33479
33480
33481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33482   int jresult ;
33483   int result;
33484
33485   result = (int)Dali::Actor::Property::PADDING;
33486   jresult = (int)result;
33487   return jresult;
33488 }
33489
33490
33491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33492   int jresult ;
33493   int result;
33494
33495   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33496   jresult = (int)result;
33497   return jresult;
33498 }
33499
33500
33501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33502   int jresult ;
33503   int result;
33504
33505   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33506   jresult = (int)result;
33507   return jresult;
33508 }
33509
33510
33511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33512   int jresult ;
33513   int result;
33514
33515   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33516   jresult = (int)result;
33517   return jresult;
33518 }
33519
33520
33521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33522   int jresult ;
33523   int result;
33524
33525   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33526   jresult = (int)result;
33527   return jresult;
33528 }
33529
33530
33531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33532   void * jresult ;
33533   Dali::Actor::Property *result = 0 ;
33534
33535   {
33536     try {
33537       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33538     } catch (std::out_of_range& e) {
33539       {
33540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33541       };
33542     } catch (std::exception& e) {
33543       {
33544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33545       };
33546     } catch (Dali::DaliException e) {
33547       {
33548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33549       };
33550     } catch (...) {
33551       {
33552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33553       };
33554     }
33555   }
33556
33557   jresult = (void *)result;
33558   return jresult;
33559 }
33560
33561
33562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33563   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33564
33565   arg1 = (Dali::Actor::Property *)jarg1;
33566   {
33567     try {
33568       delete arg1;
33569     } catch (std::out_of_range& e) {
33570       {
33571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33572       };
33573     } catch (std::exception& e) {
33574       {
33575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33576       };
33577     } catch (Dali::DaliException e) {
33578       {
33579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33580       };
33581     } catch (...) {
33582       {
33583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33584       };
33585     }
33586   }
33587
33588 }
33589
33590
33591 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33592   void * jresult ;
33593   Dali::Actor *result = 0 ;
33594
33595   {
33596     try {
33597       result = (Dali::Actor *)new Dali::Actor();
33598     } catch (std::out_of_range& e) {
33599       {
33600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33601       };
33602     } catch (std::exception& e) {
33603       {
33604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33605       };
33606     } catch (Dali::DaliException e) {
33607       {
33608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33609       };
33610     } catch (...) {
33611       {
33612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33613       };
33614     }
33615   }
33616
33617   jresult = (void *)result;
33618   return jresult;
33619 }
33620
33621
33622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33623   void * jresult ;
33624   Dali::Actor result;
33625
33626   {
33627     try {
33628       result = Dali::Actor::New();
33629     } catch (std::out_of_range& e) {
33630       {
33631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33632       };
33633     } catch (std::exception& e) {
33634       {
33635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33636       };
33637     } catch (Dali::DaliException e) {
33638       {
33639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33640       };
33641     } catch (...) {
33642       {
33643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33644       };
33645     }
33646   }
33647
33648   jresult = new Dali::Actor((const Dali::Actor &)result);
33649   return jresult;
33650 }
33651
33652
33653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33654   void * jresult ;
33655   Dali::BaseHandle arg1 ;
33656   Dali::BaseHandle *argp1 ;
33657   Dali::Actor result;
33658
33659   argp1 = (Dali::BaseHandle *)jarg1;
33660   if (!argp1) {
33661     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33662     return 0;
33663   }
33664   arg1 = *argp1;
33665   {
33666     try {
33667       result = Dali::Actor::DownCast(arg1);
33668     } catch (std::out_of_range& e) {
33669       {
33670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33671       };
33672     } catch (std::exception& e) {
33673       {
33674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33675       };
33676     } catch (Dali::DaliException e) {
33677       {
33678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33679       };
33680     } catch (...) {
33681       {
33682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33683       };
33684     }
33685   }
33686
33687   jresult = new Dali::Actor((const Dali::Actor &)result);
33688   return jresult;
33689 }
33690
33691
33692 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33693   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33694
33695   arg1 = (Dali::Actor *)jarg1;
33696   {
33697     try {
33698       delete arg1;
33699     } catch (std::out_of_range& e) {
33700       {
33701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33702       };
33703     } catch (std::exception& e) {
33704       {
33705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33706       };
33707     } catch (Dali::DaliException e) {
33708       {
33709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33710       };
33711     } catch (...) {
33712       {
33713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33714       };
33715     }
33716   }
33717
33718 }
33719
33720
33721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33722   void * jresult ;
33723   Dali::Actor *arg1 = 0 ;
33724   Dali::Actor *result = 0 ;
33725
33726   arg1 = (Dali::Actor *)jarg1;
33727   if (!arg1) {
33728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33729     return 0;
33730   }
33731   {
33732     try {
33733       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
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 (Dali::DaliException e) {
33743       {
33744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33745       };
33746     } catch (...) {
33747       {
33748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33749       };
33750     }
33751   }
33752
33753   jresult = (void *)result;
33754   return jresult;
33755 }
33756
33757
33758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33759   void * jresult ;
33760   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33761   Dali::Actor *arg2 = 0 ;
33762   Dali::Actor *result = 0 ;
33763
33764   arg1 = (Dali::Actor *)jarg1;
33765   arg2 = (Dali::Actor *)jarg2;
33766   if (!arg2) {
33767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33768     return 0;
33769   }
33770   {
33771     try {
33772       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33773     } catch (std::out_of_range& e) {
33774       {
33775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33776       };
33777     } catch (std::exception& e) {
33778       {
33779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33780       };
33781     } catch (Dali::DaliException e) {
33782       {
33783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33784       };
33785     } catch (...) {
33786       {
33787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33788       };
33789     }
33790   }
33791
33792   jresult = (void *)result;
33793   return jresult;
33794 }
33795
33796
33797 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33798   char * jresult ;
33799   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33800   std::string *result = 0 ;
33801
33802   arg1 = (Dali::Actor *)jarg1;
33803   {
33804     try {
33805       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33806       result = (std::string *) &name;
33807     } catch (std::out_of_range& e) {
33808       {
33809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33810       };
33811     } catch (std::exception& e) {
33812       {
33813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33814       };
33815     } catch (Dali::DaliException e) {
33816       {
33817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33818       };
33819     } catch (...) {
33820       {
33821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33822       };
33823     }
33824   }
33825
33826   jresult = SWIG_csharp_string_callback(result->c_str());
33827   return jresult;
33828 }
33829
33830
33831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33832   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33833   std::string *arg2 = 0 ;
33834
33835   arg1 = (Dali::Actor *)jarg1;
33836   if (!jarg2) {
33837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33838     return ;
33839   }
33840   std::string arg2_str(jarg2);
33841   arg2 = &arg2_str;
33842   {
33843     try {
33844       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33845     } catch (std::out_of_range& e) {
33846       {
33847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33848       };
33849     } catch (std::exception& e) {
33850       {
33851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33852       };
33853     } catch (Dali::DaliException e) {
33854       {
33855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33856       };
33857     } catch (...) {
33858       {
33859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33860       };
33861     }
33862   }
33863
33864
33865   //argout typemap for const std::string&
33866
33867 }
33868
33869
33870 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33871   unsigned int jresult ;
33872   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33873   unsigned int result;
33874
33875   arg1 = (Dali::Actor *)jarg1;
33876
33877   if(!arg1) {
33878     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33879     return -1;
33880   }
33881
33882   {
33883     try {
33884       result = (unsigned int)((Dali::Actor const *)arg1)->GetId();
33885     } catch (std::out_of_range& e) {
33886       {
33887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33888       };
33889     } catch (std::exception& e) {
33890       {
33891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33892       };
33893     } catch (Dali::DaliException e) {
33894       {
33895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33896       };
33897     } catch (...) {
33898       {
33899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33900       };
33901     }
33902   }
33903
33904   jresult = result;
33905   return jresult;
33906 }
33907
33908
33909 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33910   unsigned int jresult ;
33911   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33912   bool result;
33913
33914   arg1 = (Dali::Actor *)jarg1;
33915   {
33916     try {
33917       result = (bool)((Dali::Actor const *)arg1)->IsRoot();
33918     } catch (std::out_of_range& e) {
33919       {
33920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33921       };
33922     } catch (std::exception& e) {
33923       {
33924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33925       };
33926     } catch (Dali::DaliException e) {
33927       {
33928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33929       };
33930     } catch (...) {
33931       {
33932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33933       };
33934     }
33935   }
33936
33937   jresult = result;
33938   return jresult;
33939 }
33940
33941
33942 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33943   unsigned int jresult ;
33944   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33945   bool result;
33946
33947   arg1 = (Dali::Actor *)jarg1;
33948   {
33949     try {
33950       result = (bool)((Dali::Actor const *)arg1)->OnStage();
33951     } catch (std::out_of_range& e) {
33952       {
33953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33954       };
33955     } catch (std::exception& e) {
33956       {
33957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33958       };
33959     } catch (Dali::DaliException e) {
33960       {
33961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33962       };
33963     } catch (...) {
33964       {
33965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33966       };
33967     }
33968   }
33969
33970   jresult = result;
33971   return jresult;
33972 }
33973
33974
33975 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33976   unsigned int jresult ;
33977   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33978   bool result;
33979
33980   arg1 = (Dali::Actor *)jarg1;
33981   {
33982     try {
33983       result = (bool)((Dali::Actor const *)arg1)->IsLayer();
33984     } catch (std::out_of_range& e) {
33985       {
33986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33987       };
33988     } catch (std::exception& e) {
33989       {
33990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33991       };
33992     } catch (Dali::DaliException e) {
33993       {
33994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33995       };
33996     } catch (...) {
33997       {
33998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33999       };
34000     }
34001   }
34002
34003   jresult = result;
34004   return jresult;
34005 }
34006
34007
34008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
34009   void * jresult ;
34010   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34011   Dali::Layer result;
34012
34013   arg1 = (Dali::Actor *)jarg1;
34014   {
34015     try {
34016       result = (arg1)->GetLayer();
34017     } catch (std::out_of_range& e) {
34018       {
34019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34020       };
34021     } catch (std::exception& e) {
34022       {
34023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34024       };
34025     } catch (Dali::DaliException e) {
34026       {
34027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34028       };
34029     } catch (...) {
34030       {
34031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34032       };
34033     }
34034   }
34035
34036   jresult = new Dali::Layer((const Dali::Layer &)result);
34037   return jresult;
34038 }
34039
34040
34041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
34042   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34043   Dali::Actor arg2 ;
34044   Dali::Actor *argp2 ;
34045
34046   arg1 = (Dali::Actor *)jarg1;
34047   argp2 = (Dali::Actor *)jarg2;
34048   if (!argp2) {
34049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34050     return ;
34051   }
34052   arg2 = *argp2;
34053   {
34054     try {
34055       (arg1)->Add(arg2);
34056     } catch (std::out_of_range& e) {
34057       {
34058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34059       };
34060     } catch (std::exception& e) {
34061       {
34062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34063       };
34064     } catch (Dali::DaliException e) {
34065       {
34066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34067       };
34068     } catch (...) {
34069       {
34070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34071       };
34072     }
34073   }
34074
34075 }
34076
34077
34078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
34079   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34080   Dali::Actor arg2 ;
34081   Dali::Actor *argp2 ;
34082
34083   arg1 = (Dali::Actor *)jarg1;
34084   argp2 = (Dali::Actor *)jarg2;
34085   if (!argp2) {
34086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
34087     return ;
34088   }
34089   arg2 = *argp2;
34090   {
34091     try {
34092       (arg1)->Remove(arg2);
34093     } catch (std::out_of_range& e) {
34094       {
34095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34096       };
34097     } catch (std::exception& e) {
34098       {
34099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34100       };
34101     } catch (Dali::DaliException e) {
34102       {
34103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34104       };
34105     } catch (...) {
34106       {
34107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34108       };
34109     }
34110   }
34111
34112 }
34113
34114
34115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
34116   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34117
34118   arg1 = (Dali::Actor *)jarg1;
34119   {
34120     try {
34121       (arg1)->Unparent();
34122     } catch (std::out_of_range& e) {
34123       {
34124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34125       };
34126     } catch (std::exception& e) {
34127       {
34128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34129       };
34130     } catch (Dali::DaliException e) {
34131       {
34132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34133       };
34134     } catch (...) {
34135       {
34136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34137       };
34138     }
34139   }
34140
34141 }
34142
34143
34144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
34145   unsigned int jresult ;
34146   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34147   unsigned int result;
34148
34149   arg1 = (Dali::Actor *)jarg1;
34150   {
34151     try {
34152       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
34153     } catch (std::out_of_range& e) {
34154       {
34155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34156       };
34157     } catch (std::exception& e) {
34158       {
34159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34160       };
34161     } catch (Dali::DaliException e) {
34162       {
34163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34164       };
34165     } catch (...) {
34166       {
34167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34168       };
34169     }
34170   }
34171
34172   jresult = result;
34173   return jresult;
34174 }
34175
34176
34177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
34178   void * jresult ;
34179   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34180   unsigned int arg2 ;
34181   Dali::Actor result;
34182
34183   arg1 = (Dali::Actor *)jarg1;
34184   arg2 = (unsigned int)jarg2;
34185   {
34186     try {
34187       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
34188     } catch (std::out_of_range& e) {
34189       {
34190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34191       };
34192     } catch (std::exception& e) {
34193       {
34194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34195       };
34196     } catch (Dali::DaliException e) {
34197       {
34198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34199       };
34200     } catch (...) {
34201       {
34202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34203       };
34204     }
34205   }
34206
34207   jresult = new Dali::Actor((const Dali::Actor &)result);
34208   return jresult;
34209 }
34210
34211
34212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
34213   void * jresult ;
34214   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34215   std::string *arg2 = 0 ;
34216   Dali::Actor result;
34217
34218   arg1 = (Dali::Actor *)jarg1;
34219   if (!jarg2) {
34220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
34221     return 0;
34222   }
34223   std::string arg2_str(jarg2);
34224   arg2 = &arg2_str;
34225   {
34226     try {
34227       result = (arg1)->FindChildByName((std::string const &)*arg2);
34228     } catch (std::out_of_range& e) {
34229       {
34230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34231       };
34232     } catch (std::exception& e) {
34233       {
34234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34235       };
34236     } catch (Dali::DaliException e) {
34237       {
34238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34239       };
34240     } catch (...) {
34241       {
34242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34243       };
34244     }
34245   }
34246
34247   jresult = new Dali::Actor((const Dali::Actor &)result);
34248
34249   //argout typemap for const std::string&
34250
34251   return jresult;
34252 }
34253
34254
34255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
34256   void * jresult ;
34257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34258   unsigned int arg2 ;
34259   Dali::Actor result;
34260
34261   arg1 = (Dali::Actor *)jarg1;
34262   arg2 = (unsigned int)jarg2;
34263   {
34264     try {
34265       result = (arg1)->FindChildById(arg2);
34266     } catch (std::out_of_range& e) {
34267       {
34268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34269       };
34270     } catch (std::exception& e) {
34271       {
34272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34273       };
34274     } catch (Dali::DaliException e) {
34275       {
34276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34277       };
34278     } catch (...) {
34279       {
34280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34281       };
34282     }
34283   }
34284
34285   jresult = new Dali::Actor((const Dali::Actor &)result);
34286   return jresult;
34287 }
34288
34289
34290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
34291   void * jresult ;
34292   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34293   Dali::Actor result;
34294
34295   arg1 = (Dali::Actor *)jarg1;
34296   {
34297     try {
34298       result = ((Dali::Actor const *)arg1)->GetParent();
34299     } catch (std::out_of_range& e) {
34300       {
34301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34302       };
34303     } catch (std::exception& e) {
34304       {
34305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34306       };
34307     } catch (Dali::DaliException e) {
34308       {
34309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34310       };
34311     } catch (...) {
34312       {
34313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34314       };
34315     }
34316   }
34317
34318   jresult = new Dali::Actor((const Dali::Actor &)result);
34319   return jresult;
34320 }
34321
34322
34323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
34324   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34325   Dali::Vector3 *arg2 = 0 ;
34326
34327   arg1 = (Dali::Actor *)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)->SetProperty( Actor::Property::PARENT_ORIGIN,(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 (Dali::DaliException e) {
34345       {
34346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34347       };
34348     } catch (...) {
34349       {
34350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34351       };
34352     }
34353   }
34354
34355 }
34356
34357
34358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
34359   void * jresult ;
34360   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34361   Dali::Vector3 result;
34362
34363   arg1 = (Dali::Actor *)jarg1;
34364   {
34365     try {
34366       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
34367     } catch (std::out_of_range& e) {
34368       {
34369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34370       };
34371     } catch (std::exception& e) {
34372       {
34373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34374       };
34375     } catch (Dali::DaliException e) {
34376       {
34377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34378       };
34379     } catch (...) {
34380       {
34381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34382       };
34383     }
34384   }
34385
34386   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34387   return jresult;
34388 }
34389
34390
34391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34392   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34393   Dali::Vector3 *arg2 = 0 ;
34394
34395   arg1 = (Dali::Actor *)jarg1;
34396   arg2 = (Dali::Vector3 *)jarg2;
34397   if (!arg2) {
34398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34399     return ;
34400   }
34401   {
34402     try {
34403       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34404     } catch (std::out_of_range& e) {
34405       {
34406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34407       };
34408     } catch (std::exception& e) {
34409       {
34410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34411       };
34412     } catch (Dali::DaliException e) {
34413       {
34414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34415       };
34416     } catch (...) {
34417       {
34418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34419       };
34420     }
34421   }
34422
34423 }
34424
34425
34426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34427   void * jresult ;
34428   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34429   Dali::Vector3 result;
34430
34431   arg1 = (Dali::Actor *)jarg1;
34432   {
34433     try {
34434       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34435     } catch (std::out_of_range& e) {
34436       {
34437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34438       };
34439     } catch (std::exception& e) {
34440       {
34441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34442       };
34443     } catch (Dali::DaliException e) {
34444       {
34445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34446       };
34447     } catch (...) {
34448       {
34449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34450       };
34451     }
34452   }
34453
34454   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34455   return jresult;
34456 }
34457
34458
34459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34460   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34461   float arg2 ;
34462   float arg3 ;
34463
34464   arg1 = (Dali::Actor *)jarg1;
34465   arg2 = (float)jarg2;
34466   arg3 = (float)jarg3;
34467   {
34468     try {
34469       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34470     } catch (std::out_of_range& e) {
34471       {
34472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34473       };
34474     } catch (std::exception& e) {
34475       {
34476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34477       };
34478     } catch (Dali::DaliException e) {
34479       {
34480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34481       };
34482     } catch (...) {
34483       {
34484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34485       };
34486     }
34487   }
34488
34489 }
34490
34491
34492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34493   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34494   float arg2 ;
34495   float arg3 ;
34496   float arg4 ;
34497
34498   arg1 = (Dali::Actor *)jarg1;
34499   arg2 = (float)jarg2;
34500   arg3 = (float)jarg3;
34501   arg4 = (float)jarg4;
34502   {
34503     try {
34504       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34505     } catch (std::out_of_range& e) {
34506       {
34507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34508       };
34509     } catch (std::exception& e) {
34510       {
34511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34512       };
34513     } catch (Dali::DaliException e) {
34514       {
34515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34516       };
34517     } catch (...) {
34518       {
34519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34520       };
34521     }
34522   }
34523
34524 }
34525
34526
34527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34528   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34529   Dali::Vector2 *arg2 = 0 ;
34530
34531   arg1 = (Dali::Actor *)jarg1;
34532   arg2 = (Dali::Vector2 *)jarg2;
34533   if (!arg2) {
34534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34535     return ;
34536   }
34537   {
34538     try {
34539       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34540     } catch (std::out_of_range& e) {
34541       {
34542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34543       };
34544     } catch (std::exception& e) {
34545       {
34546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34547       };
34548     } catch (Dali::DaliException e) {
34549       {
34550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34551       };
34552     } catch (...) {
34553       {
34554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34555       };
34556     }
34557   }
34558
34559 }
34560
34561
34562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34563   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34564   Dali::Vector3 *arg2 = 0 ;
34565
34566   arg1 = (Dali::Actor *)jarg1;
34567   arg2 = (Dali::Vector3 *)jarg2;
34568   if (!arg2) {
34569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34570     return ;
34571   }
34572   {
34573     try {
34574       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34575     } catch (std::out_of_range& e) {
34576       {
34577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34578       };
34579     } catch (std::exception& e) {
34580       {
34581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34582       };
34583     } catch (Dali::DaliException e) {
34584       {
34585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34586       };
34587     } catch (...) {
34588       {
34589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34590       };
34591     }
34592   }
34593
34594 }
34595
34596
34597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34598   void * jresult ;
34599   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34600   Dali::Vector3 result;
34601
34602   arg1 = (Dali::Actor *)jarg1;
34603   {
34604     try {
34605       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34606     } catch (std::out_of_range& e) {
34607       {
34608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34609       };
34610     } catch (std::exception& e) {
34611       {
34612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34613       };
34614     } catch (Dali::DaliException e) {
34615       {
34616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34617       };
34618     } catch (...) {
34619       {
34620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34621       };
34622     }
34623   }
34624
34625   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34626   return jresult;
34627 }
34628
34629
34630 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34631   void * jresult ;
34632   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34633   Dali::Vector3 result;
34634
34635   arg1 = (Dali::Actor *)jarg1;
34636   {
34637     try {
34638       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34639     } catch (std::out_of_range& e) {
34640       {
34641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34642       };
34643     } catch (std::exception& e) {
34644       {
34645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34646       };
34647     } catch (Dali::DaliException e) {
34648       {
34649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34650       };
34651     } catch (...) {
34652       {
34653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34654       };
34655     }
34656   }
34657
34658   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34659   return jresult;
34660 }
34661
34662
34663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34664   void * jresult ;
34665   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34666   Dali::Vector3 result;
34667
34668   arg1 = (Dali::Actor *)jarg1;
34669   {
34670     try {
34671       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34672     } catch (std::out_of_range& e) {
34673       {
34674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34675       };
34676     } catch (std::exception& e) {
34677       {
34678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34679       };
34680     } catch (Dali::DaliException e) {
34681       {
34682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34683       };
34684     } catch (...) {
34685       {
34686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34687       };
34688     }
34689   }
34690
34691   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34692   return jresult;
34693 }
34694
34695
34696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34697   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34698   float arg2 ;
34699   float arg3 ;
34700
34701   arg1 = (Dali::Actor *)jarg1;
34702   arg2 = (float)jarg2;
34703   arg3 = (float)jarg3;
34704   {
34705     try {
34706       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34707     } catch (std::out_of_range& e) {
34708       {
34709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34710       };
34711     } catch (std::exception& e) {
34712       {
34713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34714       };
34715     } catch (Dali::DaliException e) {
34716       {
34717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34718       };
34719     } catch (...) {
34720       {
34721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34722       };
34723     }
34724   }
34725
34726 }
34727
34728
34729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34730   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34731   float arg2 ;
34732   float arg3 ;
34733   float arg4 ;
34734
34735   arg1 = (Dali::Actor *)jarg1;
34736   arg2 = (float)jarg2;
34737   arg3 = (float)jarg3;
34738   arg4 = (float)jarg4;
34739   {
34740     try {
34741       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34742     } catch (std::out_of_range& e) {
34743       {
34744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34745       };
34746     } catch (std::exception& e) {
34747       {
34748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34749       };
34750     } catch (Dali::DaliException e) {
34751       {
34752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34753       };
34754     } catch (...) {
34755       {
34756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34757       };
34758     }
34759   }
34760
34761 }
34762
34763
34764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34765   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34766   Dali::Vector3 *arg2 = 0 ;
34767
34768   arg1 = (Dali::Actor *)jarg1;
34769   arg2 = (Dali::Vector3 *)jarg2;
34770   if (!arg2) {
34771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34772     return ;
34773   }
34774   {
34775     try {
34776       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34777     } catch (std::out_of_range& e) {
34778       {
34779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34780       };
34781     } catch (std::exception& e) {
34782       {
34783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34784       };
34785     } catch (Dali::DaliException e) {
34786       {
34787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34788       };
34789     } catch (...) {
34790       {
34791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34792       };
34793     }
34794   }
34795
34796 }
34797
34798
34799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34800   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34801   float arg2 ;
34802
34803   arg1 = (Dali::Actor *)jarg1;
34804   arg2 = (float)jarg2;
34805   {
34806     try {
34807       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
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 (Dali::DaliException e) {
34817       {
34818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34819       };
34820     } catch (...) {
34821       {
34822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34823       };
34824     }
34825   }
34826
34827 }
34828
34829
34830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34831   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34832   float arg2 ;
34833
34834   arg1 = (Dali::Actor *)jarg1;
34835   arg2 = (float)jarg2;
34836   {
34837     try {
34838       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34839     } catch (std::out_of_range& e) {
34840       {
34841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34842       };
34843     } catch (std::exception& e) {
34844       {
34845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34846       };
34847     } catch (Dali::DaliException e) {
34848       {
34849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34850       };
34851     } catch (...) {
34852       {
34853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34854       };
34855     }
34856   }
34857
34858 }
34859
34860
34861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34862   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34863   float arg2 ;
34864
34865   arg1 = (Dali::Actor *)jarg1;
34866   arg2 = (float)jarg2;
34867   {
34868     try {
34869       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34870     } catch (std::out_of_range& e) {
34871       {
34872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34873       };
34874     } catch (std::exception& e) {
34875       {
34876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34877       };
34878     } catch (Dali::DaliException e) {
34879       {
34880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34881       };
34882     } catch (...) {
34883       {
34884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34885       };
34886     }
34887   }
34888
34889 }
34890
34891
34892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34893   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34894   Dali::Vector3 *arg2 = 0 ;
34895
34896   arg1 = (Dali::Actor *)jarg1;
34897   arg2 = (Dali::Vector3 *)jarg2;
34898   if (!arg2) {
34899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34900     return ;
34901   }
34902   {
34903     try {
34904       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34905     } catch (std::out_of_range& e) {
34906       {
34907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34908       };
34909     } catch (std::exception& e) {
34910       {
34911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34912       };
34913     } catch (Dali::DaliException e) {
34914       {
34915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34916       };
34917     } catch (...) {
34918       {
34919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34920       };
34921     }
34922   }
34923
34924 }
34925
34926
34927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34928   void * jresult ;
34929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34930   Dali::Vector3 result;
34931
34932   arg1 = (Dali::Actor *)jarg1;
34933   {
34934     try {
34935       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34936     } catch (std::out_of_range& e) {
34937       {
34938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34939       };
34940     } catch (std::exception& e) {
34941       {
34942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34943       };
34944     } catch (Dali::DaliException e) {
34945       {
34946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34947       };
34948     } catch (...) {
34949       {
34950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34951       };
34952     }
34953   }
34954
34955   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34956   return jresult;
34957 }
34958
34959
34960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34961   void * jresult ;
34962   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34963   Dali::Vector3 result;
34964
34965   arg1 = (Dali::Actor *)jarg1;
34966   {
34967     try {
34968       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34969     } catch (std::out_of_range& e) {
34970       {
34971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34972       };
34973     } catch (std::exception& e) {
34974       {
34975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34976       };
34977     } catch (Dali::DaliException e) {
34978       {
34979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34980       };
34981     } catch (...) {
34982       {
34983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34984       };
34985     }
34986   }
34987
34988   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34989   return jresult;
34990 }
34991
34992
34993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34994   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34995   bool arg2 ;
34996
34997   arg1 = (Dali::Actor *)jarg1;
34998   arg2 = jarg2 ? true : false;
34999   {
35000     try {
35001       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
35002     } catch (std::out_of_range& e) {
35003       {
35004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35005       };
35006     } catch (std::exception& e) {
35007       {
35008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35009       };
35010     } catch (Dali::DaliException e) {
35011       {
35012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35013       };
35014     } catch (...) {
35015       {
35016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35017       };
35018     }
35019   }
35020
35021 }
35022
35023
35024 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
35025   unsigned int jresult ;
35026   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35027   bool result;
35028
35029   arg1 = (Dali::Actor *)jarg1;
35030   {
35031     try {
35032       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
35033     } catch (std::out_of_range& e) {
35034       {
35035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35036       };
35037     } catch (std::exception& e) {
35038       {
35039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35040       };
35041     } catch (Dali::DaliException e) {
35042       {
35043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35044       };
35045     } catch (...) {
35046       {
35047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35048       };
35049     }
35050   }
35051
35052   jresult = result;
35053   return jresult;
35054 }
35055
35056
35057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35058   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35059   Dali::Degree *arg2 = 0 ;
35060   Dali::Vector3 *arg3 = 0 ;
35061
35062   arg1 = (Dali::Actor *)jarg1;
35063   arg2 = (Dali::Degree *)jarg2;
35064   if (!arg2) {
35065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35066     return ;
35067   }
35068   arg3 = (Dali::Vector3 *)jarg3;
35069   if (!arg3) {
35070     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35071     return ;
35072   }
35073   {
35074     try {
35075       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35076     } catch (std::out_of_range& e) {
35077       {
35078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35079       };
35080     } catch (std::exception& e) {
35081       {
35082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35083       };
35084     } catch (Dali::DaliException e) {
35085       {
35086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35087       };
35088     } catch (...) {
35089       {
35090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35091       };
35092     }
35093   }
35094
35095 }
35096
35097
35098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35099   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35100   Dali::Radian *arg2 = 0 ;
35101   Dali::Vector3 *arg3 = 0 ;
35102
35103   arg1 = (Dali::Actor *)jarg1;
35104   arg2 = (Dali::Radian *)jarg2;
35105   if (!arg2) {
35106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35107     return ;
35108   }
35109   arg3 = (Dali::Vector3 *)jarg3;
35110   if (!arg3) {
35111     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35112     return ;
35113   }
35114   {
35115     try {
35116       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
35117     } catch (std::out_of_range& e) {
35118       {
35119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35120       };
35121     } catch (std::exception& e) {
35122       {
35123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35124       };
35125     } catch (Dali::DaliException e) {
35126       {
35127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35128       };
35129     } catch (...) {
35130       {
35131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35132       };
35133     }
35134   }
35135
35136 }
35137
35138
35139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
35140   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35141   Dali::Quaternion *arg2 = 0 ;
35142
35143   arg1 = (Dali::Actor *)jarg1;
35144   arg2 = (Dali::Quaternion *)jarg2;
35145   if (!arg2) {
35146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35147     return ;
35148   }
35149   {
35150     try {
35151       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
35152     } catch (std::out_of_range& e) {
35153       {
35154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35155       };
35156     } catch (std::exception& e) {
35157       {
35158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35159       };
35160     } catch (Dali::DaliException e) {
35161       {
35162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35163       };
35164     } catch (...) {
35165       {
35166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35167       };
35168     }
35169   }
35170
35171 }
35172
35173
35174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
35175   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35176   Dali::Degree *arg2 = 0 ;
35177   Dali::Vector3 *arg3 = 0 ;
35178
35179   arg1 = (Dali::Actor *)jarg1;
35180   arg2 = (Dali::Degree *)jarg2;
35181   if (!arg2) {
35182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
35183     return ;
35184   }
35185   arg3 = (Dali::Vector3 *)jarg3;
35186   if (!arg3) {
35187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35188     return ;
35189   }
35190   {
35191     try {
35192       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
35193     } catch (std::out_of_range& e) {
35194       {
35195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35196       };
35197     } catch (std::exception& e) {
35198       {
35199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35200       };
35201     } catch (Dali::DaliException e) {
35202       {
35203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35204       };
35205     } catch (...) {
35206       {
35207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35208       };
35209     }
35210   }
35211
35212 }
35213
35214
35215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
35216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35217   Dali::Radian *arg2 = 0 ;
35218   Dali::Vector3 *arg3 = 0 ;
35219
35220   arg1 = (Dali::Actor *)jarg1;
35221   arg2 = (Dali::Radian *)jarg2;
35222   if (!arg2) {
35223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
35224     return ;
35225   }
35226   arg3 = (Dali::Vector3 *)jarg3;
35227   if (!arg3) {
35228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35229     return ;
35230   }
35231   {
35232     try {
35233       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
35234     } catch (std::out_of_range& e) {
35235       {
35236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35237       };
35238     } catch (std::exception& e) {
35239       {
35240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35241       };
35242     } catch (Dali::DaliException e) {
35243       {
35244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35245       };
35246     } catch (...) {
35247       {
35248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35249       };
35250     }
35251   }
35252
35253 }
35254
35255
35256 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
35257   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35258   Dali::Quaternion *arg2 = 0 ;
35259
35260   arg1 = (Dali::Actor *)jarg1;
35261   arg2 = (Dali::Quaternion *)jarg2;
35262   if (!arg2) {
35263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
35264     return ;
35265   }
35266   {
35267     try {
35268       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
35269     } catch (std::out_of_range& e) {
35270       {
35271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35272       };
35273     } catch (std::exception& e) {
35274       {
35275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35276       };
35277     } catch (Dali::DaliException e) {
35278       {
35279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35280       };
35281     } catch (...) {
35282       {
35283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35284       };
35285     }
35286   }
35287
35288 }
35289
35290
35291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
35292   void * jresult ;
35293   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35294   Dali::Quaternion result;
35295
35296   arg1 = (Dali::Actor *)jarg1;
35297   {
35298     try {
35299       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
35300     } catch (std::out_of_range& e) {
35301       {
35302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35303       };
35304     } catch (std::exception& e) {
35305       {
35306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35307       };
35308     } catch (Dali::DaliException e) {
35309       {
35310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35311       };
35312     } catch (...) {
35313       {
35314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35315       };
35316     }
35317   }
35318
35319   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35320   return jresult;
35321 }
35322
35323
35324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
35325   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35326   bool arg2 ;
35327
35328   arg1 = (Dali::Actor *)jarg1;
35329   arg2 = jarg2 ? true : false;
35330   {
35331     try {
35332       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
35333     } catch (std::out_of_range& e) {
35334       {
35335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35336       };
35337     } catch (std::exception& e) {
35338       {
35339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35340       };
35341     } catch (Dali::DaliException e) {
35342       {
35343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35344       };
35345     } catch (...) {
35346       {
35347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35348       };
35349     }
35350   }
35351
35352 }
35353
35354
35355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
35356   unsigned int jresult ;
35357   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35358   bool result;
35359
35360   arg1 = (Dali::Actor *)jarg1;
35361   {
35362     try {
35363       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
35364     } catch (std::out_of_range& e) {
35365       {
35366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35367       };
35368     } catch (std::exception& e) {
35369       {
35370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35371       };
35372     } catch (Dali::DaliException e) {
35373       {
35374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35375       };
35376     } catch (...) {
35377       {
35378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35379       };
35380     }
35381   }
35382
35383   jresult = result;
35384   return jresult;
35385 }
35386
35387
35388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35389   void * jresult ;
35390   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35391   Dali::Quaternion result;
35392
35393   arg1 = (Dali::Actor *)jarg1;
35394   {
35395     try {
35396       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35397     } catch (std::out_of_range& e) {
35398       {
35399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35400       };
35401     } catch (std::exception& e) {
35402       {
35403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35404       };
35405     } catch (Dali::DaliException e) {
35406       {
35407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35408       };
35409     } catch (...) {
35410       {
35411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35412       };
35413     }
35414   }
35415
35416   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35417   return jresult;
35418 }
35419
35420
35421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35422   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35423   float arg2 ;
35424
35425   arg1 = (Dali::Actor *)jarg1;
35426   arg2 = (float)jarg2;
35427   {
35428     try {
35429       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
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 (Dali::DaliException e) {
35439       {
35440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35441       };
35442     } catch (...) {
35443       {
35444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35445       };
35446     }
35447   }
35448
35449 }
35450
35451
35452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35453   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35454   float arg2 ;
35455   float arg3 ;
35456   float arg4 ;
35457
35458   arg1 = (Dali::Actor *)jarg1;
35459   arg2 = (float)jarg2;
35460   arg3 = (float)jarg3;
35461   arg4 = (float)jarg4;
35462   {
35463     try {
35464       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35465     } catch (std::out_of_range& e) {
35466       {
35467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35468       };
35469     } catch (std::exception& e) {
35470       {
35471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35472       };
35473     } catch (Dali::DaliException e) {
35474       {
35475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35476       };
35477     } catch (...) {
35478       {
35479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35480       };
35481     }
35482   }
35483
35484 }
35485
35486
35487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35488   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35489   Dali::Vector3 *arg2 = 0 ;
35490
35491   arg1 = (Dali::Actor *)jarg1;
35492   arg2 = (Dali::Vector3 *)jarg2;
35493   if (!arg2) {
35494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35495     return ;
35496   }
35497   {
35498     try {
35499       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35500     } catch (std::out_of_range& e) {
35501       {
35502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35503       };
35504     } catch (std::exception& e) {
35505       {
35506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35507       };
35508     } catch (Dali::DaliException e) {
35509       {
35510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35511       };
35512     } catch (...) {
35513       {
35514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35515       };
35516     }
35517   }
35518
35519 }
35520
35521
35522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35523   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35524   Dali::Vector3 *arg2 = 0 ;
35525
35526   arg1 = (Dali::Actor *)jarg1;
35527   arg2 = (Dali::Vector3 *)jarg2;
35528   if (!arg2) {
35529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35530     return ;
35531   }
35532   {
35533     try {
35534       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35535     } catch (std::out_of_range& e) {
35536       {
35537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35538       };
35539     } catch (std::exception& e) {
35540       {
35541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35542       };
35543     } catch (Dali::DaliException e) {
35544       {
35545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35546       };
35547     } catch (...) {
35548       {
35549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35550       };
35551     }
35552   }
35553
35554 }
35555
35556
35557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35558   void * jresult ;
35559   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35560   Dali::Vector3 result;
35561
35562   arg1 = (Dali::Actor *)jarg1;
35563   {
35564     try {
35565       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35566     } catch (std::out_of_range& e) {
35567       {
35568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35569       };
35570     } catch (std::exception& e) {
35571       {
35572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35573       };
35574     } catch (Dali::DaliException e) {
35575       {
35576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35577       };
35578     } catch (...) {
35579       {
35580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35581       };
35582     }
35583   }
35584
35585   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35586   return jresult;
35587 }
35588
35589
35590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35591   void * jresult ;
35592   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35593   Dali::Vector3 result;
35594
35595   arg1 = (Dali::Actor *)jarg1;
35596   {
35597     try {
35598       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35599     } catch (std::out_of_range& e) {
35600       {
35601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35602       };
35603     } catch (std::exception& e) {
35604       {
35605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35606       };
35607     } catch (Dali::DaliException e) {
35608       {
35609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35610       };
35611     } catch (...) {
35612       {
35613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35614       };
35615     }
35616   }
35617
35618   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35619   return jresult;
35620 }
35621
35622
35623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35624   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35625   bool arg2 ;
35626
35627   arg1 = (Dali::Actor *)jarg1;
35628   arg2 = jarg2 ? true : false;
35629   {
35630     try {
35631       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35632     } catch (std::out_of_range& e) {
35633       {
35634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35635       };
35636     } catch (std::exception& e) {
35637       {
35638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35639       };
35640     } catch (Dali::DaliException e) {
35641       {
35642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35643       };
35644     } catch (...) {
35645       {
35646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35647       };
35648     }
35649   }
35650
35651 }
35652
35653
35654 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35655   unsigned int jresult ;
35656   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35657   bool result;
35658
35659   arg1 = (Dali::Actor *)jarg1;
35660   {
35661     try {
35662       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35663     } catch (std::out_of_range& e) {
35664       {
35665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35666       };
35667     } catch (std::exception& e) {
35668       {
35669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35670       };
35671     } catch (Dali::DaliException e) {
35672       {
35673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35674       };
35675     } catch (...) {
35676       {
35677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35678       };
35679     }
35680   }
35681
35682   jresult = result;
35683   return jresult;
35684 }
35685
35686
35687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35688   void * jresult ;
35689   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35690   Dali::Matrix result;
35691
35692   arg1 = (Dali::Actor *)jarg1;
35693   {
35694     try {
35695       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35696     } catch (std::out_of_range& e) {
35697       {
35698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35699       };
35700     } catch (std::exception& e) {
35701       {
35702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35703       };
35704     } catch (Dali::DaliException e) {
35705       {
35706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35707       };
35708     } catch (...) {
35709       {
35710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35711       };
35712     }
35713   }
35714
35715   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35716   return jresult;
35717 }
35718
35719
35720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35721   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35722   bool arg2 ;
35723
35724   arg1 = (Dali::Actor *)jarg1;
35725   arg2 = jarg2 ? true : false;
35726   {
35727     try {
35728       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35729     } catch (std::out_of_range& e) {
35730       {
35731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35732       };
35733     } catch (std::exception& e) {
35734       {
35735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35736       };
35737     } catch (Dali::DaliException e) {
35738       {
35739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35740       };
35741     } catch (...) {
35742       {
35743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35744       };
35745     }
35746   }
35747
35748 }
35749
35750
35751 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35752   unsigned int jresult ;
35753   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35754   bool result;
35755
35756   arg1 = (Dali::Actor *)jarg1;
35757   {
35758     try {
35759       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35760     } catch (std::out_of_range& e) {
35761       {
35762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35763       };
35764     } catch (std::exception& e) {
35765       {
35766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35767       };
35768     } catch (Dali::DaliException e) {
35769       {
35770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35771       };
35772     } catch (...) {
35773       {
35774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35775       };
35776     }
35777   }
35778
35779   jresult = result;
35780   return jresult;
35781 }
35782
35783
35784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35785   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35786   float arg2 ;
35787
35788   arg1 = (Dali::Actor *)jarg1;
35789   arg2 = (float)jarg2;
35790   {
35791     try {
35792       (arg1)->SetProperty( DevelActor::Property::OPACITY,arg2);
35793     } catch (std::out_of_range& e) {
35794       {
35795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35796       };
35797     } catch (std::exception& e) {
35798       {
35799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35800       };
35801     } catch (Dali::DaliException e) {
35802       {
35803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35804       };
35805     } catch (...) {
35806       {
35807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35808       };
35809     }
35810   }
35811
35812 }
35813
35814
35815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35816   float jresult ;
35817   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35818   float result;
35819
35820   arg1 = (Dali::Actor *)jarg1;
35821   {
35822     try {
35823       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( DevelActor::Property::OPACITY );
35824     } catch (std::out_of_range& e) {
35825       {
35826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35827       };
35828     } catch (std::exception& e) {
35829       {
35830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35831       };
35832     } catch (Dali::DaliException e) {
35833       {
35834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35835       };
35836     } catch (...) {
35837       {
35838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35839       };
35840     }
35841   }
35842
35843   jresult = result;
35844   return jresult;
35845 }
35846
35847
35848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35849   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35850   Dali::Vector4 *arg2 = 0 ;
35851
35852   arg1 = (Dali::Actor *)jarg1;
35853   arg2 = (Dali::Vector4 *)jarg2;
35854   if (!arg2) {
35855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35856     return ;
35857   }
35858   {
35859     try {
35860       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35861     } catch (std::out_of_range& e) {
35862       {
35863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35864       };
35865     } catch (std::exception& e) {
35866       {
35867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35868       };
35869     } catch (Dali::DaliException e) {
35870       {
35871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35872       };
35873     } catch (...) {
35874       {
35875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35876       };
35877     }
35878   }
35879
35880 }
35881
35882
35883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35884   void * jresult ;
35885   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35886   Dali::Vector4 result;
35887
35888   arg1 = (Dali::Actor *)jarg1;
35889   {
35890     try {
35891       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35892     } catch (std::out_of_range& e) {
35893       {
35894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35895       };
35896     } catch (std::exception& e) {
35897       {
35898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35899       };
35900     } catch (Dali::DaliException e) {
35901       {
35902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35903       };
35904     } catch (...) {
35905       {
35906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35907       };
35908     }
35909   }
35910
35911   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35912   return jresult;
35913 }
35914
35915
35916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35918   Dali::ColorMode arg2 ;
35919
35920   arg1 = (Dali::Actor *)jarg1;
35921   arg2 = (Dali::ColorMode)jarg2;
35922   {
35923     try {
35924       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35925     } catch (std::out_of_range& e) {
35926       {
35927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35928       };
35929     } catch (std::exception& e) {
35930       {
35931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35932       };
35933     } catch (Dali::DaliException e) {
35934       {
35935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35936       };
35937     } catch (...) {
35938       {
35939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35940       };
35941     }
35942   }
35943
35944 }
35945
35946
35947 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35948   int jresult ;
35949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35950   Dali::ColorMode result;
35951
35952   arg1 = (Dali::Actor *)jarg1;
35953   {
35954     try {
35955       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35956     } catch (std::out_of_range& e) {
35957       {
35958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35959       };
35960     } catch (std::exception& e) {
35961       {
35962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35963       };
35964     } catch (Dali::DaliException e) {
35965       {
35966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35967       };
35968     } catch (...) {
35969       {
35970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35971       };
35972     }
35973   }
35974
35975   jresult = (int)result;
35976   return jresult;
35977 }
35978
35979
35980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35981   void * jresult ;
35982   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35983   Dali::Vector4 result;
35984
35985   arg1 = (Dali::Actor *)jarg1;
35986   {
35987     try {
35988       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35989     } catch (std::out_of_range& e) {
35990       {
35991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35992       };
35993     } catch (std::exception& e) {
35994       {
35995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35996       };
35997     } catch (Dali::DaliException e) {
35998       {
35999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36000       };
36001     } catch (...) {
36002       {
36003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36004       };
36005     }
36006   }
36007
36008   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
36009   return jresult;
36010 }
36011
36012
36013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
36014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36015   Dali::DrawMode::Type arg2 ;
36016
36017   arg1 = (Dali::Actor *)jarg1;
36018   arg2 = (Dali::DrawMode::Type)jarg2;
36019   {
36020     try {
36021       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
36022     } catch (std::out_of_range& e) {
36023       {
36024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36025       };
36026     } catch (std::exception& e) {
36027       {
36028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36029       };
36030     } catch (Dali::DaliException e) {
36031       {
36032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36033       };
36034     } catch (...) {
36035       {
36036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36037       };
36038     }
36039   }
36040
36041 }
36042
36043
36044 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
36045   int jresult ;
36046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36047   Dali::DrawMode::Type result;
36048
36049   arg1 = (Dali::Actor *)jarg1;
36050   {
36051     try {
36052       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
36053     } catch (std::out_of_range& e) {
36054       {
36055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36056       };
36057     } catch (std::exception& e) {
36058       {
36059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36060       };
36061     } catch (Dali::DaliException e) {
36062       {
36063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36064       };
36065     } catch (...) {
36066       {
36067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36068       };
36069     }
36070   }
36071
36072   jresult = (int)result;
36073   return jresult;
36074 }
36075
36076
36077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
36078   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36079   bool arg2 ;
36080
36081   arg1 = (Dali::Actor *)jarg1;
36082   arg2 = jarg2 ? true : false;
36083   {
36084     try {
36085       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
36086     } catch (std::out_of_range& e) {
36087       {
36088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36089       };
36090     } catch (std::exception& e) {
36091       {
36092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36093       };
36094     } catch (Dali::DaliException e) {
36095       {
36096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36097       };
36098     } catch (...) {
36099       {
36100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36101       };
36102     }
36103   }
36104
36105 }
36106
36107
36108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
36109   unsigned int jresult ;
36110   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36111   bool result;
36112
36113   arg1 = (Dali::Actor *)jarg1;
36114   {
36115     try {
36116       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
36117     } catch (std::out_of_range& e) {
36118       {
36119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36120       };
36121     } catch (std::exception& e) {
36122       {
36123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36124       };
36125     } catch (Dali::DaliException e) {
36126       {
36127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36128       };
36129     } catch (...) {
36130       {
36131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36132       };
36133     }
36134   }
36135
36136   jresult = result;
36137   return jresult;
36138 }
36139
36140
36141 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
36142   unsigned int jresult ;
36143   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36144   float *arg2 = 0 ;
36145   float *arg3 = 0 ;
36146   float arg4 ;
36147   float arg5 ;
36148   bool result;
36149
36150   arg1 = (Dali::Actor *)jarg1;
36151   arg2 = (float *)jarg2;
36152   arg3 = (float *)jarg3;
36153   arg4 = (float)jarg4;
36154   arg5 = (float)jarg5;
36155   {
36156     try {
36157       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
36158     } catch (std::out_of_range& e) {
36159       {
36160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36161       };
36162     } catch (std::exception& e) {
36163       {
36164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36165       };
36166     } catch (Dali::DaliException e) {
36167       {
36168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36169       };
36170     } catch (...) {
36171       {
36172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36173       };
36174     }
36175   }
36176
36177   jresult = result;
36178   return jresult;
36179 }
36180
36181
36182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
36183   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36184   bool arg2 ;
36185
36186   arg1 = (Dali::Actor *)jarg1;
36187   arg2 = jarg2 ? true : false;
36188   {
36189     try {
36190       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
36191     } catch (std::out_of_range& e) {
36192       {
36193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36194       };
36195     } catch (std::exception& e) {
36196       {
36197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36198       };
36199     } catch (Dali::DaliException e) {
36200       {
36201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36202       };
36203     } catch (...) {
36204       {
36205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36206       };
36207     }
36208   }
36209
36210 }
36211
36212
36213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
36214   unsigned int jresult ;
36215   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36216   bool result;
36217
36218   arg1 = (Dali::Actor *)jarg1;
36219   {
36220     try {
36221       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
36222     } catch (std::out_of_range& e) {
36223       {
36224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36225       };
36226     } catch (std::exception& e) {
36227       {
36228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36229       };
36230     } catch (Dali::DaliException e) {
36231       {
36232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36233       };
36234     } catch (...) {
36235       {
36236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36237       };
36238     }
36239   }
36240
36241   jresult = result;
36242   return jresult;
36243 }
36244
36245
36246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
36247   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36248   bool arg2 ;
36249
36250   arg1 = (Dali::Actor *)jarg1;
36251   arg2 = jarg2 ? true : false;
36252   {
36253     try {
36254       (arg1)->SetKeyboardFocusable(arg2);
36255     } catch (std::out_of_range& e) {
36256       {
36257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36258       };
36259     } catch (std::exception& e) {
36260       {
36261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36262       };
36263     } catch (Dali::DaliException e) {
36264       {
36265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36266       };
36267     } catch (...) {
36268       {
36269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36270       };
36271     }
36272   }
36273
36274 }
36275
36276
36277 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
36278   unsigned int jresult ;
36279   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36280   bool result;
36281
36282   arg1 = (Dali::Actor *)jarg1;
36283   {
36284     try {
36285       result = (bool)((Dali::Actor const *)arg1)->IsKeyboardFocusable();
36286     } catch (std::out_of_range& e) {
36287       {
36288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36289       };
36290     } catch (std::exception& e) {
36291       {
36292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36293       };
36294     } catch (Dali::DaliException e) {
36295       {
36296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36297       };
36298     } catch (...) {
36299       {
36300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36301       };
36302     }
36303   }
36304
36305   jresult = result;
36306   return jresult;
36307 }
36308
36309
36310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
36311   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36312   Dali::ResizePolicy::Type arg2 ;
36313   Dali::Dimension::Type arg3 ;
36314
36315   arg1 = (Dali::Actor *)jarg1;
36316   arg2 = (Dali::ResizePolicy::Type)jarg2;
36317   arg3 = (Dali::Dimension::Type)jarg3;
36318   {
36319     try {
36320       (arg1)->SetResizePolicy(arg2,arg3);
36321     } catch (std::out_of_range& e) {
36322       {
36323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36324       };
36325     } catch (std::exception& e) {
36326       {
36327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36328       };
36329     } catch (Dali::DaliException e) {
36330       {
36331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36332       };
36333     } catch (...) {
36334       {
36335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36336       };
36337     }
36338   }
36339
36340 }
36341
36342
36343 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
36344   int jresult ;
36345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36346   Dali::Dimension::Type arg2 ;
36347   Dali::ResizePolicy::Type result;
36348
36349   arg1 = (Dali::Actor *)jarg1;
36350   arg2 = (Dali::Dimension::Type)jarg2;
36351   {
36352     try {
36353       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
36354     } catch (std::out_of_range& e) {
36355       {
36356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36357       };
36358     } catch (std::exception& e) {
36359       {
36360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36361       };
36362     } catch (Dali::DaliException e) {
36363       {
36364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36365       };
36366     } catch (...) {
36367       {
36368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36369       };
36370     }
36371   }
36372
36373   jresult = (int)result;
36374   return jresult;
36375 }
36376
36377
36378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36379   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36380   Dali::SizeScalePolicy::Type arg2 ;
36381
36382   arg1 = (Dali::Actor *)jarg1;
36383   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36384   {
36385     try {
36386       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36387     } catch (std::out_of_range& e) {
36388       {
36389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36390       };
36391     } catch (std::exception& e) {
36392       {
36393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36394       };
36395     } catch (Dali::DaliException e) {
36396       {
36397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36398       };
36399     } catch (...) {
36400       {
36401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36402       };
36403     }
36404   }
36405
36406 }
36407
36408
36409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36410   int jresult ;
36411   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36412   Dali::SizeScalePolicy::Type result;
36413
36414   arg1 = (Dali::Actor *)jarg1;
36415   {
36416     try {
36417       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36418     } catch (std::out_of_range& e) {
36419       {
36420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36421       };
36422     } catch (std::exception& e) {
36423       {
36424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36425       };
36426     } catch (Dali::DaliException e) {
36427       {
36428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36429       };
36430     } catch (...) {
36431       {
36432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36433       };
36434     }
36435   }
36436
36437   jresult = (int)result;
36438   return jresult;
36439 }
36440
36441
36442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36443   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36444   Dali::Vector3 *arg2 = 0 ;
36445
36446   arg1 = (Dali::Actor *)jarg1;
36447   arg2 = (Dali::Vector3 *)jarg2;
36448   if (!arg2) {
36449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36450     return ;
36451   }
36452   {
36453     try {
36454       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36455     } catch (std::out_of_range& e) {
36456       {
36457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36458       };
36459     } catch (std::exception& e) {
36460       {
36461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36462       };
36463     } catch (Dali::DaliException e) {
36464       {
36465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36466       };
36467     } catch (...) {
36468       {
36469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36470       };
36471     }
36472   }
36473
36474 }
36475
36476
36477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36478   void * jresult ;
36479   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36480   Dali::Vector3 result;
36481
36482   arg1 = (Dali::Actor *)jarg1;
36483   {
36484     try {
36485       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36486     } catch (std::out_of_range& e) {
36487       {
36488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36489       };
36490     } catch (std::exception& e) {
36491       {
36492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36493       };
36494     } catch (Dali::DaliException e) {
36495       {
36496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36497       };
36498     } catch (...) {
36499       {
36500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36501       };
36502     }
36503   }
36504
36505   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36506   return jresult;
36507 }
36508
36509
36510 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36511   float jresult ;
36512   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36513   float arg2 ;
36514   float result;
36515
36516   arg1 = (Dali::Actor *)jarg1;
36517   arg2 = (float)jarg2;
36518   {
36519     try {
36520       result = (float)(arg1)->GetHeightForWidth(arg2);
36521     } catch (std::out_of_range& e) {
36522       {
36523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36524       };
36525     } catch (std::exception& e) {
36526       {
36527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36528       };
36529     } catch (Dali::DaliException e) {
36530       {
36531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36532       };
36533     } catch (...) {
36534       {
36535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36536       };
36537     }
36538   }
36539
36540   jresult = result;
36541   return jresult;
36542 }
36543
36544
36545 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36546   float jresult ;
36547   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36548   float arg2 ;
36549   float result;
36550
36551   arg1 = (Dali::Actor *)jarg1;
36552   arg2 = (float)jarg2;
36553   {
36554     try {
36555       result = (float)(arg1)->GetWidthForHeight(arg2);
36556     } catch (std::out_of_range& e) {
36557       {
36558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36559       };
36560     } catch (std::exception& e) {
36561       {
36562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36563       };
36564     } catch (Dali::DaliException e) {
36565       {
36566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36567       };
36568     } catch (...) {
36569       {
36570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36571       };
36572     }
36573   }
36574
36575   jresult = result;
36576   return jresult;
36577 }
36578
36579
36580 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36581   float jresult ;
36582   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36583   Dali::Dimension::Type arg2 ;
36584   float result;
36585
36586   arg1 = (Dali::Actor *)jarg1;
36587   arg2 = (Dali::Dimension::Type)jarg2;
36588   {
36589     try {
36590       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36591     } catch (std::out_of_range& e) {
36592       {
36593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36594       };
36595     } catch (std::exception& e) {
36596       {
36597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36598       };
36599     } catch (Dali::DaliException e) {
36600       {
36601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36602       };
36603     } catch (...) {
36604       {
36605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36606       };
36607     }
36608   }
36609
36610   jresult = result;
36611   return jresult;
36612 }
36613
36614
36615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36616   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36617   Dali::Padding *arg2 = 0 ;
36618
36619   arg1 = (Dali::Actor *)jarg1;
36620   arg2 = (Dali::Padding *)jarg2;
36621   if (!arg2) {
36622     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36623     return ;
36624   }
36625   {
36626     try {
36627       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36628     } catch (std::out_of_range& e) {
36629       {
36630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36631       };
36632     } catch (std::exception& e) {
36633       {
36634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36635       };
36636     } catch (Dali::DaliException e) {
36637       {
36638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36639       };
36640     } catch (...) {
36641       {
36642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36643       };
36644     }
36645   }
36646
36647 }
36648
36649
36650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36651   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36652   Dali::Padding *arg2 = 0 ;
36653
36654   arg1 = (Dali::Actor *)jarg1;
36655   arg2 = (Dali::Padding *)jarg2;
36656   if (!arg2) {
36657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36658     return ;
36659   }
36660   {
36661     try {
36662       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36663     } catch (std::out_of_range& e) {
36664       {
36665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36666       };
36667     } catch (std::exception& e) {
36668       {
36669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36670       };
36671     } catch (Dali::DaliException e) {
36672       {
36673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36674       };
36675     } catch (...) {
36676       {
36677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36678       };
36679     }
36680   }
36681
36682 }
36683
36684
36685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36686   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36687   Dali::Vector2 *arg2 = 0 ;
36688
36689   arg1 = (Dali::Actor *)jarg1;
36690   arg2 = (Dali::Vector2 *)jarg2;
36691   if (!arg2) {
36692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36693     return ;
36694   }
36695   {
36696     try {
36697       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36698     } catch (std::out_of_range& e) {
36699       {
36700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36701       };
36702     } catch (std::exception& e) {
36703       {
36704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36705       };
36706     } catch (Dali::DaliException e) {
36707       {
36708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36709       };
36710     } catch (...) {
36711       {
36712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36713       };
36714     }
36715   }
36716
36717 }
36718
36719
36720 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36721   void * jresult ;
36722   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36723   Dali::Vector2 result;
36724
36725   arg1 = (Dali::Actor *)jarg1;
36726   {
36727     try {
36728       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36729     } catch (std::out_of_range& e) {
36730       {
36731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36732       };
36733     } catch (std::exception& e) {
36734       {
36735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36736       };
36737     } catch (Dali::DaliException e) {
36738       {
36739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36740       };
36741     } catch (...) {
36742       {
36743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36744       };
36745     }
36746   }
36747
36748   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36749   return jresult;
36750 }
36751
36752
36753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36754   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36755   Dali::Vector2 *arg2 = 0 ;
36756
36757   arg1 = (Dali::Actor *)jarg1;
36758   arg2 = (Dali::Vector2 *)jarg2;
36759   if (!arg2) {
36760     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36761     return ;
36762   }
36763   {
36764     try {
36765       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36766     } catch (std::out_of_range& e) {
36767       {
36768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36769       };
36770     } catch (std::exception& e) {
36771       {
36772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36773       };
36774     } catch (Dali::DaliException e) {
36775       {
36776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36777       };
36778     } catch (...) {
36779       {
36780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36781       };
36782     }
36783   }
36784
36785 }
36786
36787
36788 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36789   void * jresult ;
36790   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36791   Dali::Vector2 result;
36792
36793   arg1 = (Dali::Actor *)jarg1;
36794   {
36795     try {
36796       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36797     } catch (std::out_of_range& e) {
36798       {
36799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36800       };
36801     } catch (std::exception& e) {
36802       {
36803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36804       };
36805     } catch (Dali::DaliException e) {
36806       {
36807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36808       };
36809     } catch (...) {
36810       {
36811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36812       };
36813     }
36814   }
36815
36816   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36817   return jresult;
36818 }
36819
36820
36821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36822   int jresult ;
36823   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36824   int result;
36825
36826   arg1 = (Dali::Actor *)jarg1;
36827   {
36828     try {
36829       result = (int)(arg1)->GetHierarchyDepth();
36830       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36831     } catch (std::out_of_range& e) {
36832       {
36833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36834       };
36835     } catch (std::exception& e) {
36836       {
36837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36838       };
36839     } catch (Dali::DaliException e) {
36840       {
36841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36842       };
36843     } catch (...) {
36844       {
36845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36846       };
36847     }
36848   }
36849
36850   jresult = result;
36851   return jresult;
36852 }
36853
36854
36855 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36856   unsigned int jresult ;
36857   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36858   Dali::Renderer *arg2 = 0 ;
36859   unsigned int result;
36860
36861   arg1 = (Dali::Actor *)jarg1;
36862   arg2 = (Dali::Renderer *)jarg2;
36863   if (!arg2) {
36864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36865     return 0;
36866   }
36867   {
36868     try {
36869       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36870     } catch (std::out_of_range& e) {
36871       {
36872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36873       };
36874     } catch (std::exception& e) {
36875       {
36876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36877       };
36878     } catch (Dali::DaliException e) {
36879       {
36880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36881       };
36882     } catch (...) {
36883       {
36884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36885       };
36886     }
36887   }
36888
36889   jresult = result;
36890   return jresult;
36891 }
36892
36893
36894 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36895   unsigned int jresult ;
36896   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36897   unsigned int result;
36898
36899   arg1 = (Dali::Actor *)jarg1;
36900   {
36901     try {
36902       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36903     } catch (std::out_of_range& e) {
36904       {
36905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36906       };
36907     } catch (std::exception& e) {
36908       {
36909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36910       };
36911     } catch (Dali::DaliException e) {
36912       {
36913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36914       };
36915     } catch (...) {
36916       {
36917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36918       };
36919     }
36920   }
36921
36922   jresult = result;
36923   return jresult;
36924 }
36925
36926
36927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36928   void * jresult ;
36929   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36930   unsigned int arg2 ;
36931   Dali::Renderer result;
36932
36933   arg1 = (Dali::Actor *)jarg1;
36934   arg2 = (unsigned int)jarg2;
36935   {
36936     try {
36937       result = (arg1)->GetRendererAt(arg2);
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 (Dali::DaliException e) {
36947       {
36948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36949       };
36950     } catch (...) {
36951       {
36952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36953       };
36954     }
36955   }
36956
36957   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36958   return jresult;
36959 }
36960
36961
36962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36963   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36964   Dali::Renderer *arg2 = 0 ;
36965
36966   arg1 = (Dali::Actor *)jarg1;
36967   arg2 = (Dali::Renderer *)jarg2;
36968   if (!arg2) {
36969     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36970     return ;
36971   }
36972   {
36973     try {
36974       (arg1)->RemoveRenderer(*arg2);
36975     } catch (std::out_of_range& e) {
36976       {
36977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36978       };
36979     } catch (std::exception& e) {
36980       {
36981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36982       };
36983     } catch (Dali::DaliException e) {
36984       {
36985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36986       };
36987     } catch (...) {
36988       {
36989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36990       };
36991     }
36992   }
36993
36994 }
36995
36996
36997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36998   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36999   unsigned int arg2 ;
37000
37001   arg1 = (Dali::Actor *)jarg1;
37002   arg2 = (unsigned int)jarg2;
37003   {
37004     try {
37005       (arg1)->RemoveRenderer(arg2);
37006     } catch (std::out_of_range& e) {
37007       {
37008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37009       };
37010     } catch (std::exception& e) {
37011       {
37012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37013       };
37014     } catch (Dali::DaliException e) {
37015       {
37016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37017       };
37018     } catch (...) {
37019       {
37020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37021       };
37022     }
37023   }
37024
37025 }
37026
37027
37028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchedSignal(void * jarg1) {
37029   void * jresult ;
37030   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37031   Dali::Actor::TouchSignalType *result = 0 ;
37032
37033   arg1 = (Dali::Actor *)jarg1;
37034   {
37035     try {
37036       result = (Dali::Actor::TouchSignalType *) &(arg1)->TouchedSignal();
37037     } catch (std::out_of_range& e) {
37038       {
37039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37040       };
37041     } catch (std::exception& e) {
37042       {
37043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37044       };
37045     } catch (Dali::DaliException e) {
37046       {
37047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37048       };
37049     } catch (...) {
37050       {
37051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37052       };
37053     }
37054   }
37055
37056   jresult = (void *)result;
37057   return jresult;
37058 }
37059
37060
37061 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
37062   void * jresult ;
37063   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37064   Dali::Actor::TouchDataSignalType *result = 0 ;
37065
37066   arg1 = (Dali::Actor *)jarg1;
37067   {
37068     try {
37069       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
37070     } catch (std::out_of_range& e) {
37071       {
37072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37073       };
37074     } catch (std::exception& e) {
37075       {
37076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37077       };
37078     } catch (Dali::DaliException e) {
37079       {
37080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37081       };
37082     } catch (...) {
37083       {
37084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37085       };
37086     }
37087   }
37088
37089   jresult = (void *)result;
37090   return jresult;
37091 }
37092
37093
37094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
37095   void * jresult ;
37096   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37097   Dali::Actor::HoverSignalType *result = 0 ;
37098
37099   arg1 = (Dali::Actor *)jarg1;
37100   {
37101     try {
37102       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
37103     } catch (std::out_of_range& e) {
37104       {
37105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37106       };
37107     } catch (std::exception& e) {
37108       {
37109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37110       };
37111     } catch (Dali::DaliException e) {
37112       {
37113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37114       };
37115     } catch (...) {
37116       {
37117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37118       };
37119     }
37120   }
37121
37122   jresult = (void *)result;
37123   return jresult;
37124 }
37125
37126
37127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
37128   void * jresult ;
37129   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37130   Dali::Actor::WheelEventSignalType *result = 0 ;
37131
37132   arg1 = (Dali::Actor *)jarg1;
37133   {
37134     try {
37135       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
37136     } catch (std::out_of_range& e) {
37137       {
37138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37139       };
37140     } catch (std::exception& e) {
37141       {
37142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37143       };
37144     } catch (Dali::DaliException e) {
37145       {
37146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37147       };
37148     } catch (...) {
37149       {
37150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37151       };
37152     }
37153   }
37154
37155   jresult = (void *)result;
37156   return jresult;
37157 }
37158
37159
37160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
37161   void * jresult ;
37162   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37163   Dali::Actor::OnStageSignalType *result = 0 ;
37164
37165   arg1 = (Dali::Actor *)jarg1;
37166   {
37167     try {
37168       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
37169     } catch (std::out_of_range& e) {
37170       {
37171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37172       };
37173     } catch (std::exception& e) {
37174       {
37175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37176       };
37177     } catch (Dali::DaliException e) {
37178       {
37179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37180       };
37181     } catch (...) {
37182       {
37183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37184       };
37185     }
37186   }
37187
37188   jresult = (void *)result;
37189   return jresult;
37190 }
37191
37192
37193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
37194   void * jresult ;
37195   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37196   Dali::Actor::OffStageSignalType *result = 0 ;
37197
37198   arg1 = (Dali::Actor *)jarg1;
37199   {
37200     try {
37201       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
37202     } catch (std::out_of_range& e) {
37203       {
37204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37205       };
37206     } catch (std::exception& e) {
37207       {
37208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37209       };
37210     } catch (Dali::DaliException e) {
37211       {
37212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37213       };
37214     } catch (...) {
37215       {
37216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37217       };
37218     }
37219   }
37220
37221   jresult = (void *)result;
37222   return jresult;
37223 }
37224
37225
37226 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
37227   void * jresult ;
37228   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
37229   Dali::Actor::OnRelayoutSignalType *result = 0 ;
37230
37231   arg1 = (Dali::Actor *)jarg1;
37232   {
37233     try {
37234       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
37235     } catch (std::out_of_range& e) {
37236       {
37237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37238       };
37239     } catch (std::exception& e) {
37240       {
37241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37242       };
37243     } catch (Dali::DaliException e) {
37244       {
37245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37246       };
37247     } catch (...) {
37248       {
37249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37250       };
37251     }
37252   }
37253
37254   jresult = (void *)result;
37255   return jresult;
37256 }
37257
37258
37259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
37260   Dali::Actor *arg1 = 0 ;
37261
37262   arg1 = (Dali::Actor *)jarg1;
37263   if (!arg1) {
37264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
37265     return ;
37266   }
37267   {
37268     try {
37269       Dali::UnparentAndReset(*arg1);
37270     } catch (std::out_of_range& e) {
37271       {
37272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37273       };
37274     } catch (std::exception& e) {
37275       {
37276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37277       };
37278     } catch (Dali::DaliException e) {
37279       {
37280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37281       };
37282     } catch (...) {
37283       {
37284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37285       };
37286     }
37287   }
37288
37289 }
37290
37291
37292 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
37293   int jresult ;
37294   int result;
37295
37296   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
37297   jresult = (int)result;
37298   return jresult;
37299 }
37300
37301
37302 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
37303   int jresult ;
37304   int result;
37305
37306   result = (int)Dali::Layer::Property::CLIPPING_BOX;
37307   jresult = (int)result;
37308   return jresult;
37309 }
37310
37311
37312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
37313   int jresult ;
37314   int result;
37315
37316   result = (int)Dali::Layer::Property::BEHAVIOR;
37317   jresult = (int)result;
37318   return jresult;
37319 }
37320
37321
37322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
37323   void * jresult ;
37324   Dali::Layer::Property *result = 0 ;
37325
37326   {
37327     try {
37328       result = (Dali::Layer::Property *)new Dali::Layer::Property();
37329     } catch (std::out_of_range& e) {
37330       {
37331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37332       };
37333     } catch (std::exception& e) {
37334       {
37335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37336       };
37337     } catch (Dali::DaliException e) {
37338       {
37339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37340       };
37341     } catch (...) {
37342       {
37343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37344       };
37345     }
37346   }
37347
37348   jresult = (void *)result;
37349   return jresult;
37350 }
37351
37352
37353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
37354   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
37355
37356   arg1 = (Dali::Layer::Property *)jarg1;
37357   {
37358     try {
37359       delete arg1;
37360     } catch (std::out_of_range& e) {
37361       {
37362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37363       };
37364     } catch (std::exception& e) {
37365       {
37366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37367       };
37368     } catch (Dali::DaliException e) {
37369       {
37370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37371       };
37372     } catch (...) {
37373       {
37374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37375       };
37376     }
37377   }
37378
37379 }
37380
37381
37382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
37383   void * jresult ;
37384   Dali::Layer *result = 0 ;
37385
37386   {
37387     try {
37388       result = (Dali::Layer *)new Dali::Layer();
37389     } catch (std::out_of_range& e) {
37390       {
37391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37392       };
37393     } catch (std::exception& e) {
37394       {
37395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37396       };
37397     } catch (Dali::DaliException e) {
37398       {
37399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37400       };
37401     } catch (...) {
37402       {
37403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37404       };
37405     }
37406   }
37407
37408   jresult = (void *)result;
37409   return jresult;
37410 }
37411
37412
37413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37414   void * jresult ;
37415   Dali::Layer result;
37416
37417   {
37418     try {
37419       result = Dali::Layer::New();
37420     } catch (std::out_of_range& e) {
37421       {
37422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37423       };
37424     } catch (std::exception& e) {
37425       {
37426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37427       };
37428     } catch (Dali::DaliException e) {
37429       {
37430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37431       };
37432     } catch (...) {
37433       {
37434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37435       };
37436     }
37437   }
37438
37439   jresult = new Dali::Layer((const Dali::Layer &)result);
37440   return jresult;
37441 }
37442
37443
37444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37445   void * jresult ;
37446   Dali::BaseHandle arg1 ;
37447   Dali::BaseHandle *argp1 ;
37448   Dali::Layer result;
37449
37450   argp1 = (Dali::BaseHandle *)jarg1;
37451   if (!argp1) {
37452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37453     return 0;
37454   }
37455   arg1 = *argp1;
37456   {
37457     try {
37458       result = Dali::Layer::DownCast(arg1);
37459     } catch (std::out_of_range& e) {
37460       {
37461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37462       };
37463     } catch (std::exception& e) {
37464       {
37465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37466       };
37467     } catch (Dali::DaliException e) {
37468       {
37469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37470       };
37471     } catch (...) {
37472       {
37473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37474       };
37475     }
37476   }
37477
37478   jresult = new Dali::Layer((const Dali::Layer &)result);
37479   return jresult;
37480 }
37481
37482
37483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37484   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37485
37486   arg1 = (Dali::Layer *)jarg1;
37487   {
37488     try {
37489       delete arg1;
37490     } catch (std::out_of_range& e) {
37491       {
37492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37493       };
37494     } catch (std::exception& e) {
37495       {
37496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37497       };
37498     } catch (Dali::DaliException e) {
37499       {
37500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37501       };
37502     } catch (...) {
37503       {
37504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37505       };
37506     }
37507   }
37508
37509 }
37510
37511
37512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37513   void * jresult ;
37514   Dali::Layer *arg1 = 0 ;
37515   Dali::Layer *result = 0 ;
37516
37517   arg1 = (Dali::Layer *)jarg1;
37518   if (!arg1) {
37519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37520     return 0;
37521   }
37522   {
37523     try {
37524       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37525     } catch (std::out_of_range& e) {
37526       {
37527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37528       };
37529     } catch (std::exception& e) {
37530       {
37531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37532       };
37533     } catch (Dali::DaliException e) {
37534       {
37535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37536       };
37537     } catch (...) {
37538       {
37539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37540       };
37541     }
37542   }
37543
37544   jresult = (void *)result;
37545   return jresult;
37546 }
37547
37548
37549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37550   void * jresult ;
37551   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37552   Dali::Layer *arg2 = 0 ;
37553   Dali::Layer *result = 0 ;
37554
37555   arg1 = (Dali::Layer *)jarg1;
37556   arg2 = (Dali::Layer *)jarg2;
37557   if (!arg2) {
37558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37559     return 0;
37560   }
37561   {
37562     try {
37563       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37564     } catch (std::out_of_range& e) {
37565       {
37566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37567       };
37568     } catch (std::exception& e) {
37569       {
37570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37571       };
37572     } catch (Dali::DaliException e) {
37573       {
37574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37575       };
37576     } catch (...) {
37577       {
37578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37579       };
37580     }
37581   }
37582
37583   jresult = (void *)result;
37584   return jresult;
37585 }
37586
37587
37588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37589   unsigned int jresult ;
37590   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37591   unsigned int result;
37592
37593   arg1 = (Dali::Layer *)jarg1;
37594   {
37595     try {
37596       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37597     } catch (std::out_of_range& e) {
37598       {
37599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37600       };
37601     } catch (std::exception& e) {
37602       {
37603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37604       };
37605     } catch (Dali::DaliException e) {
37606       {
37607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37608       };
37609     } catch (...) {
37610       {
37611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37612       };
37613     }
37614   }
37615
37616   jresult = result;
37617   return jresult;
37618 }
37619
37620
37621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37622   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37623
37624   arg1 = (Dali::Layer *)jarg1;
37625   {
37626     try {
37627       (arg1)->Raise();
37628     } catch (std::out_of_range& e) {
37629       {
37630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37631       };
37632     } catch (std::exception& e) {
37633       {
37634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37635       };
37636     } catch (Dali::DaliException e) {
37637       {
37638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37639       };
37640     } catch (...) {
37641       {
37642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37643       };
37644     }
37645   }
37646
37647 }
37648
37649
37650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37651   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37652
37653   arg1 = (Dali::Layer *)jarg1;
37654   {
37655     try {
37656       (arg1)->Lower();
37657     } catch (std::out_of_range& e) {
37658       {
37659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37660       };
37661     } catch (std::exception& e) {
37662       {
37663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37664       };
37665     } catch (Dali::DaliException e) {
37666       {
37667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37668       };
37669     } catch (...) {
37670       {
37671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37672       };
37673     }
37674   }
37675
37676 }
37677
37678
37679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37680   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37681   Dali::Layer arg2 ;
37682   Dali::Layer *argp2 ;
37683
37684   arg1 = (Dali::Layer *)jarg1;
37685   argp2 = (Dali::Layer *)jarg2;
37686   if (!argp2) {
37687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37688     return ;
37689   }
37690   arg2 = *argp2;
37691   {
37692     try {
37693       (arg1)->RaiseAbove(arg2);
37694     } catch (std::out_of_range& e) {
37695       {
37696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37697       };
37698     } catch (std::exception& e) {
37699       {
37700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37701       };
37702     } catch (Dali::DaliException e) {
37703       {
37704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37705       };
37706     } catch (...) {
37707       {
37708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37709       };
37710     }
37711   }
37712
37713 }
37714
37715
37716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37717   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37718   Dali::Layer arg2 ;
37719   Dali::Layer *argp2 ;
37720
37721   arg1 = (Dali::Layer *)jarg1;
37722   argp2 = (Dali::Layer *)jarg2;
37723   if (!argp2) {
37724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37725     return ;
37726   }
37727   arg2 = *argp2;
37728   {
37729     try {
37730       (arg1)->LowerBelow(arg2);
37731     } catch (std::out_of_range& e) {
37732       {
37733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37734       };
37735     } catch (std::exception& e) {
37736       {
37737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37738       };
37739     } catch (Dali::DaliException e) {
37740       {
37741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37742       };
37743     } catch (...) {
37744       {
37745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37746       };
37747     }
37748   }
37749
37750 }
37751
37752
37753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37754   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37755
37756   arg1 = (Dali::Layer *)jarg1;
37757   {
37758     try {
37759       (arg1)->RaiseToTop();
37760     } catch (std::out_of_range& e) {
37761       {
37762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37763       };
37764     } catch (std::exception& e) {
37765       {
37766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37767       };
37768     } catch (Dali::DaliException e) {
37769       {
37770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37771       };
37772     } catch (...) {
37773       {
37774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37775       };
37776     }
37777   }
37778
37779 }
37780
37781
37782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37783   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37784
37785   arg1 = (Dali::Layer *)jarg1;
37786   {
37787     try {
37788       (arg1)->LowerToBottom();
37789     } catch (std::out_of_range& e) {
37790       {
37791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37792       };
37793     } catch (std::exception& e) {
37794       {
37795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37796       };
37797     } catch (Dali::DaliException e) {
37798       {
37799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37800       };
37801     } catch (...) {
37802       {
37803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37804       };
37805     }
37806   }
37807
37808 }
37809
37810
37811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37812   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37813   Dali::Layer arg2 ;
37814   Dali::Layer *argp2 ;
37815
37816   arg1 = (Dali::Layer *)jarg1;
37817   argp2 = (Dali::Layer *)jarg2;
37818   if (!argp2) {
37819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37820     return ;
37821   }
37822   arg2 = *argp2;
37823   {
37824     try {
37825       (arg1)->MoveAbove(arg2);
37826     } catch (std::out_of_range& e) {
37827       {
37828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37829       };
37830     } catch (std::exception& e) {
37831       {
37832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37833       };
37834     } catch (Dali::DaliException e) {
37835       {
37836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37837       };
37838     } catch (...) {
37839       {
37840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37841       };
37842     }
37843   }
37844
37845 }
37846
37847
37848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37849   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37850   Dali::Layer arg2 ;
37851   Dali::Layer *argp2 ;
37852
37853   arg1 = (Dali::Layer *)jarg1;
37854   argp2 = (Dali::Layer *)jarg2;
37855   if (!argp2) {
37856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37857     return ;
37858   }
37859   arg2 = *argp2;
37860   {
37861     try {
37862       (arg1)->MoveBelow(arg2);
37863     } catch (std::out_of_range& e) {
37864       {
37865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37866       };
37867     } catch (std::exception& e) {
37868       {
37869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37870       };
37871     } catch (Dali::DaliException e) {
37872       {
37873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37874       };
37875     } catch (...) {
37876       {
37877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37878       };
37879     }
37880   }
37881
37882 }
37883
37884
37885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37886   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37887   Dali::Layer::Behavior arg2 ;
37888
37889   arg1 = (Dali::Layer *)jarg1;
37890   arg2 = (Dali::Layer::Behavior)jarg2;
37891   {
37892     try {
37893       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37894     } catch (std::out_of_range& e) {
37895       {
37896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37897       };
37898     } catch (std::exception& e) {
37899       {
37900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37901       };
37902     } catch (Dali::DaliException e) {
37903       {
37904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37905       };
37906     } catch (...) {
37907       {
37908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37909       };
37910     }
37911   }
37912
37913 }
37914
37915
37916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37917   int jresult ;
37918   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37919   Dali::Layer::Behavior result;
37920
37921   arg1 = (Dali::Layer *)jarg1;
37922   {
37923     try {
37924       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37925     } catch (std::out_of_range& e) {
37926       {
37927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37928       };
37929     } catch (std::exception& e) {
37930       {
37931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37932       };
37933     } catch (Dali::DaliException e) {
37934       {
37935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37936       };
37937     } catch (...) {
37938       {
37939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37940       };
37941     }
37942   }
37943
37944   jresult = (int)result;
37945   return jresult;
37946 }
37947
37948
37949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37950   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37951   bool arg2 ;
37952
37953   arg1 = (Dali::Layer *)jarg1;
37954   arg2 = jarg2 ? true : false;
37955   {
37956     try {
37957       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37958     } catch (std::out_of_range& e) {
37959       {
37960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37961       };
37962     } catch (std::exception& e) {
37963       {
37964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37965       };
37966     } catch (Dali::DaliException e) {
37967       {
37968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37969       };
37970     } catch (...) {
37971       {
37972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37973       };
37974     }
37975   }
37976
37977 }
37978
37979
37980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37981   unsigned int jresult ;
37982   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37983   bool result;
37984
37985   arg1 = (Dali::Layer *)jarg1;
37986   {
37987     try {
37988       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37989     } catch (std::out_of_range& e) {
37990       {
37991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37992       };
37993     } catch (std::exception& e) {
37994       {
37995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37996       };
37997     } catch (Dali::DaliException e) {
37998       {
37999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38000       };
38001     } catch (...) {
38002       {
38003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38004       };
38005     }
38006   }
38007
38008   jresult = result;
38009   return jresult;
38010 }
38011
38012
38013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
38014   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38015   int arg2 ;
38016   int arg3 ;
38017   int arg4 ;
38018   int arg5 ;
38019
38020   arg1 = (Dali::Layer *)jarg1;
38021   arg2 = (int)jarg2;
38022   arg3 = (int)jarg3;
38023   arg4 = (int)jarg4;
38024   arg5 = (int)jarg5;
38025   {
38026     try {
38027       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
38028     } catch (std::out_of_range& e) {
38029       {
38030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38031       };
38032     } catch (std::exception& e) {
38033       {
38034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38035       };
38036     } catch (Dali::DaliException e) {
38037       {
38038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38039       };
38040     } catch (...) {
38041       {
38042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38043       };
38044     }
38045   }
38046
38047 }
38048
38049
38050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
38051   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38052   Dali::ClippingBox arg2 ;
38053   Dali::ClippingBox *argp2 ;
38054
38055   arg1 = (Dali::Layer *)jarg1;
38056   argp2 = (Dali::ClippingBox *)jarg2;
38057   if (!argp2) {
38058     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
38059     return ;
38060   }
38061   arg2 = *argp2;
38062   {
38063     try {
38064       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
38065     } catch (std::out_of_range& e) {
38066       {
38067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38068       };
38069     } catch (std::exception& e) {
38070       {
38071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38072       };
38073     } catch (Dali::DaliException e) {
38074       {
38075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38076       };
38077     } catch (...) {
38078       {
38079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38080       };
38081     }
38082   }
38083
38084 }
38085
38086
38087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
38088   void * jresult ;
38089   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38090   Dali::ClippingBox result;
38091
38092   arg1 = (Dali::Layer *)jarg1;
38093   {
38094     try {
38095       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
38096     } catch (std::out_of_range& e) {
38097       {
38098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38099       };
38100     } catch (std::exception& e) {
38101       {
38102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38103       };
38104     } catch (Dali::DaliException e) {
38105       {
38106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38107       };
38108     } catch (...) {
38109       {
38110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38111       };
38112     }
38113   }
38114
38115   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
38116   return jresult;
38117 }
38118
38119
38120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
38121   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38122   bool arg2 ;
38123
38124   arg1 = (Dali::Layer *)jarg1;
38125   arg2 = jarg2 ? true : false;
38126   {
38127     try {
38128       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
38129     } catch (std::out_of_range& e) {
38130       {
38131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38132       };
38133     } catch (std::exception& e) {
38134       {
38135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38136       };
38137     } catch (Dali::DaliException e) {
38138       {
38139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38140       };
38141     } catch (...) {
38142       {
38143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38144       };
38145     }
38146   }
38147
38148 }
38149
38150
38151 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
38152   unsigned int jresult ;
38153   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38154   bool result;
38155
38156   arg1 = (Dali::Layer *)jarg1;
38157   {
38158     try {
38159       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
38160     } catch (std::out_of_range& e) {
38161       {
38162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38163       };
38164     } catch (std::exception& e) {
38165       {
38166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38167       };
38168     } catch (Dali::DaliException e) {
38169       {
38170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38171       };
38172     } catch (...) {
38173       {
38174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38175       };
38176     }
38177   }
38178
38179   jresult = result;
38180   return jresult;
38181 }
38182
38183
38184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
38185   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38186   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
38187
38188   arg1 = (Dali::Layer *)jarg1;
38189   arg2 = (Dali::Layer::SortFunctionType)jarg2;
38190   {
38191     try {
38192       (arg1)->SetSortFunction(arg2);
38193     } catch (std::out_of_range& e) {
38194       {
38195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38196       };
38197     } catch (std::exception& e) {
38198       {
38199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38200       };
38201     } catch (Dali::DaliException e) {
38202       {
38203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38204       };
38205     } catch (...) {
38206       {
38207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38208       };
38209     }
38210   }
38211
38212 }
38213
38214
38215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
38216   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38217   bool arg2 ;
38218
38219   arg1 = (Dali::Layer *)jarg1;
38220   arg2 = jarg2 ? true : false;
38221   {
38222     try {
38223       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
38224     } catch (std::out_of_range& e) {
38225       {
38226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38227       };
38228     } catch (std::exception& e) {
38229       {
38230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38231       };
38232     } catch (Dali::DaliException e) {
38233       {
38234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38235       };
38236     } catch (...) {
38237       {
38238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38239       };
38240     }
38241   }
38242
38243 }
38244
38245
38246 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
38247   unsigned int jresult ;
38248   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38249   bool result;
38250
38251   arg1 = (Dali::Layer *)jarg1;
38252   {
38253     try {
38254       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
38255     } catch (std::out_of_range& e) {
38256       {
38257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38258       };
38259     } catch (std::exception& e) {
38260       {
38261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38262       };
38263     } catch (Dali::DaliException e) {
38264       {
38265         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38266       };
38267     } catch (...) {
38268       {
38269         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38270       };
38271     }
38272   }
38273
38274   jresult = result;
38275   return jresult;
38276 }
38277
38278
38279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
38280   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38281   bool arg2 ;
38282
38283   arg1 = (Dali::Layer *)jarg1;
38284   arg2 = jarg2 ? true : false;
38285   {
38286     try {
38287       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
38288     } catch (std::out_of_range& e) {
38289       {
38290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38291       };
38292     } catch (std::exception& e) {
38293       {
38294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38295       };
38296     } catch (Dali::DaliException e) {
38297       {
38298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38299       };
38300     } catch (...) {
38301       {
38302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38303       };
38304     }
38305   }
38306
38307 }
38308
38309
38310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
38311   unsigned int jresult ;
38312   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
38313   bool result;
38314
38315   arg1 = (Dali::Layer *)jarg1;
38316   {
38317     try {
38318       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
38319     } catch (std::out_of_range& e) {
38320       {
38321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38322       };
38323     } catch (std::exception& e) {
38324       {
38325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38326       };
38327     } catch (Dali::DaliException e) {
38328       {
38329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38330       };
38331     } catch (...) {
38332       {
38333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38334       };
38335     }
38336   }
38337
38338   jresult = result;
38339   return jresult;
38340 }
38341
38342
38343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
38344   void * jresult ;
38345   Dali::Vector4 *result = 0 ;
38346
38347   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
38348   jresult = (void *)result;
38349   return jresult;
38350 }
38351
38352
38353 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
38354   void * jresult ;
38355   Dali::Vector4 *result = 0 ;
38356
38357   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
38358   jresult = (void *)result;
38359   return jresult;
38360 }
38361
38362
38363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
38364   void * jresult ;
38365   Dali::Stage *result = 0 ;
38366
38367   {
38368     try {
38369       result = (Dali::Stage *)new Dali::Stage();
38370     } catch (std::out_of_range& e) {
38371       {
38372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38373       };
38374     } catch (std::exception& e) {
38375       {
38376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38377       };
38378     } catch (Dali::DaliException e) {
38379       {
38380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38381       };
38382     } catch (...) {
38383       {
38384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38385       };
38386     }
38387   }
38388
38389   jresult = (void *)result;
38390   return jresult;
38391 }
38392
38393
38394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
38395   void * jresult ;
38396   Dali::Stage result;
38397
38398   {
38399     try {
38400       result = Dali::Stage::GetCurrent();
38401     } catch (std::out_of_range& e) {
38402       {
38403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38404       };
38405     } catch (std::exception& e) {
38406       {
38407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38408       };
38409     } catch (Dali::DaliException e) {
38410       {
38411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38412       };
38413     } catch (...) {
38414       {
38415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38416       };
38417     }
38418   }
38419
38420   jresult = new Dali::Stage((const Dali::Stage &)result);
38421   return jresult;
38422 }
38423
38424
38425 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38426   unsigned int jresult ;
38427   bool result;
38428
38429   {
38430     try {
38431       result = (bool)Dali::Stage::IsInstalled();
38432     } catch (std::out_of_range& e) {
38433       {
38434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38435       };
38436     } catch (std::exception& e) {
38437       {
38438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38439       };
38440     } catch (Dali::DaliException e) {
38441       {
38442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38443       };
38444     } catch (...) {
38445       {
38446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38447       };
38448     }
38449   }
38450
38451   jresult = result;
38452   return jresult;
38453 }
38454
38455
38456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38457   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38458
38459   arg1 = (Dali::Stage *)jarg1;
38460   {
38461     try {
38462       delete arg1;
38463     } catch (std::out_of_range& e) {
38464       {
38465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38466       };
38467     } catch (std::exception& e) {
38468       {
38469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38470       };
38471     } catch (Dali::DaliException e) {
38472       {
38473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38474       };
38475     } catch (...) {
38476       {
38477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38478       };
38479     }
38480   }
38481
38482 }
38483
38484
38485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38486   void * jresult ;
38487   Dali::Stage *arg1 = 0 ;
38488   Dali::Stage *result = 0 ;
38489
38490   arg1 = (Dali::Stage *)jarg1;
38491   if (!arg1) {
38492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38493     return 0;
38494   }
38495   {
38496     try {
38497       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38498     } catch (std::out_of_range& e) {
38499       {
38500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38501       };
38502     } catch (std::exception& e) {
38503       {
38504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38505       };
38506     } catch (Dali::DaliException e) {
38507       {
38508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38509       };
38510     } catch (...) {
38511       {
38512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38513       };
38514     }
38515   }
38516
38517   jresult = (void *)result;
38518   return jresult;
38519 }
38520
38521
38522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38523   void * jresult ;
38524   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38525   Dali::Stage *arg2 = 0 ;
38526   Dali::Stage *result = 0 ;
38527
38528   arg1 = (Dali::Stage *)jarg1;
38529   arg2 = (Dali::Stage *)jarg2;
38530   if (!arg2) {
38531     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38532     return 0;
38533   }
38534   {
38535     try {
38536       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38537     } catch (std::out_of_range& e) {
38538       {
38539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38540       };
38541     } catch (std::exception& e) {
38542       {
38543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38544       };
38545     } catch (Dali::DaliException e) {
38546       {
38547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38548       };
38549     } catch (...) {
38550       {
38551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38552       };
38553     }
38554   }
38555
38556   jresult = (void *)result;
38557   return jresult;
38558 }
38559
38560
38561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38562   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38563   Dali::Actor *arg2 = 0 ;
38564
38565   arg1 = (Dali::Stage *)jarg1;
38566   arg2 = (Dali::Actor *)jarg2;
38567   if (!arg2) {
38568     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38569     return ;
38570   }
38571   {
38572     try {
38573       (arg1)->Add(*arg2);
38574     } catch (std::out_of_range& e) {
38575       {
38576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38577       };
38578     } catch (std::exception& e) {
38579       {
38580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38581       };
38582     } catch (Dali::DaliException e) {
38583       {
38584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38585       };
38586     } catch (...) {
38587       {
38588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38589       };
38590     }
38591   }
38592
38593 }
38594
38595
38596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38597   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38598   Dali::Actor *arg2 = 0 ;
38599
38600   arg1 = (Dali::Stage *)jarg1;
38601   arg2 = (Dali::Actor *)jarg2;
38602   if (!arg2) {
38603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38604     return ;
38605   }
38606   {
38607     try {
38608       (arg1)->Remove(*arg2);
38609     } catch (std::out_of_range& e) {
38610       {
38611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38612       };
38613     } catch (std::exception& e) {
38614       {
38615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38616       };
38617     } catch (Dali::DaliException e) {
38618       {
38619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38620       };
38621     } catch (...) {
38622       {
38623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38624       };
38625     }
38626   }
38627
38628 }
38629
38630
38631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38632   void * jresult ;
38633   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38634   Dali::Vector2 result;
38635
38636   arg1 = (Dali::Stage *)jarg1;
38637   {
38638     try {
38639       result = ((Dali::Stage const *)arg1)->GetSize();
38640     } catch (std::out_of_range& e) {
38641       {
38642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38643       };
38644     } catch (std::exception& e) {
38645       {
38646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38647       };
38648     } catch (Dali::DaliException e) {
38649       {
38650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38651       };
38652     } catch (...) {
38653       {
38654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38655       };
38656     }
38657   }
38658
38659   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38660   return jresult;
38661 }
38662
38663
38664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38665   void * jresult ;
38666   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38667   Dali::RenderTaskList result;
38668
38669   arg1 = (Dali::Stage *)jarg1;
38670   {
38671     try {
38672       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38673     } catch (std::out_of_range& e) {
38674       {
38675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38676       };
38677     } catch (std::exception& e) {
38678       {
38679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38680       };
38681     } catch (Dali::DaliException e) {
38682       {
38683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38684       };
38685     } catch (...) {
38686       {
38687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38688       };
38689     }
38690   }
38691
38692   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38693   return jresult;
38694 }
38695
38696
38697 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38698   unsigned int jresult ;
38699   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38700   unsigned int result;
38701
38702   arg1 = (Dali::Stage *)jarg1;
38703   {
38704     try {
38705       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38706     } catch (std::out_of_range& e) {
38707       {
38708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38709       };
38710     } catch (std::exception& e) {
38711       {
38712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38713       };
38714     } catch (Dali::DaliException e) {
38715       {
38716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38717       };
38718     } catch (...) {
38719       {
38720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38721       };
38722     }
38723   }
38724
38725   jresult = result;
38726   return jresult;
38727 }
38728
38729
38730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38731   void * jresult ;
38732   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38733   unsigned int arg2 ;
38734   Dali::Layer result;
38735
38736   arg1 = (Dali::Stage *)jarg1;
38737   arg2 = (unsigned int)jarg2;
38738   {
38739     try {
38740       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38741     } catch (std::out_of_range& e) {
38742       {
38743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38744       };
38745     } catch (std::exception& e) {
38746       {
38747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38748       };
38749     } catch (Dali::DaliException e) {
38750       {
38751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38752       };
38753     } catch (...) {
38754       {
38755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38756       };
38757     }
38758   }
38759
38760   jresult = new Dali::Layer((const Dali::Layer &)result);
38761   return jresult;
38762 }
38763
38764
38765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38766   void * jresult ;
38767   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38768   Dali::Layer result;
38769
38770   arg1 = (Dali::Stage *)jarg1;
38771   {
38772     try {
38773       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38774     } catch (std::out_of_range& e) {
38775       {
38776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38777       };
38778     } catch (std::exception& e) {
38779       {
38780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38781       };
38782     } catch (Dali::DaliException e) {
38783       {
38784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38785       };
38786     } catch (...) {
38787       {
38788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38789       };
38790     }
38791   }
38792
38793   jresult = new Dali::Layer((const Dali::Layer &)result);
38794   return jresult;
38795 }
38796
38797
38798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38799   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38800   Dali::Vector4 arg2 ;
38801   Dali::Vector4 *argp2 ;
38802
38803   arg1 = (Dali::Stage *)jarg1;
38804   argp2 = (Dali::Vector4 *)jarg2;
38805   if (!argp2) {
38806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38807     return ;
38808   }
38809   arg2 = *argp2;
38810   {
38811     try {
38812       (arg1)->SetBackgroundColor(arg2);
38813     } catch (std::out_of_range& e) {
38814       {
38815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38816       };
38817     } catch (std::exception& e) {
38818       {
38819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38820       };
38821     } catch (Dali::DaliException e) {
38822       {
38823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38824       };
38825     } catch (...) {
38826       {
38827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38828       };
38829     }
38830   }
38831
38832 }
38833
38834
38835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38836   void * jresult ;
38837   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38838   Dali::Vector4 result;
38839
38840   arg1 = (Dali::Stage *)jarg1;
38841   {
38842     try {
38843       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38844     } catch (std::out_of_range& e) {
38845       {
38846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38847       };
38848     } catch (std::exception& e) {
38849       {
38850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38851       };
38852     } catch (Dali::DaliException e) {
38853       {
38854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38855       };
38856     } catch (...) {
38857       {
38858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38859       };
38860     }
38861   }
38862
38863   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38864   return jresult;
38865 }
38866
38867
38868 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38869   void * jresult ;
38870   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38871   Dali::Vector2 result;
38872
38873   arg1 = (Dali::Stage *)jarg1;
38874   {
38875     try {
38876       result = ((Dali::Stage const *)arg1)->GetDpi();
38877     } catch (std::out_of_range& e) {
38878       {
38879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38880       };
38881     } catch (std::exception& e) {
38882       {
38883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38884       };
38885     } catch (Dali::DaliException e) {
38886       {
38887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38888       };
38889     } catch (...) {
38890       {
38891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38892       };
38893     }
38894   }
38895
38896   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38897   return jresult;
38898 }
38899
38900
38901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38902   void * jresult ;
38903   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38904   Dali::ObjectRegistry result;
38905
38906   arg1 = (Dali::Stage *)jarg1;
38907   {
38908     try {
38909       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38910     } catch (std::out_of_range& e) {
38911       {
38912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38913       };
38914     } catch (std::exception& e) {
38915       {
38916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38917       };
38918     } catch (Dali::DaliException e) {
38919       {
38920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38921       };
38922     } catch (...) {
38923       {
38924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38925       };
38926     }
38927   }
38928
38929   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38930   return jresult;
38931 }
38932
38933
38934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38935   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38936   float arg2 ;
38937
38938   arg1 = (Dali::Stage *)jarg1;
38939   arg2 = (float)jarg2;
38940   {
38941     try {
38942       (arg1)->KeepRendering(arg2);
38943     } catch (std::out_of_range& e) {
38944       {
38945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38946       };
38947     } catch (std::exception& e) {
38948       {
38949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38950       };
38951     } catch (Dali::DaliException e) {
38952       {
38953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38954       };
38955     } catch (...) {
38956       {
38957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38958       };
38959     }
38960   }
38961
38962 }
38963
38964
38965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38966   void * jresult ;
38967   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38968   Dali::Stage::KeyEventSignalType *result = 0 ;
38969
38970   arg1 = (Dali::Stage *)jarg1;
38971   {
38972     try {
38973       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38974     } catch (std::out_of_range& e) {
38975       {
38976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38977       };
38978     } catch (std::exception& e) {
38979       {
38980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38981       };
38982     } catch (Dali::DaliException e) {
38983       {
38984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38985       };
38986     } catch (...) {
38987       {
38988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38989       };
38990     }
38991   }
38992
38993   jresult = (void *)result;
38994   return jresult;
38995 }
38996
38997
38998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38999   void * jresult ;
39000   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39001   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
39002
39003   arg1 = (Dali::Stage *)jarg1;
39004   {
39005     try {
39006       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
39007     } catch (std::out_of_range& e) {
39008       {
39009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39010       };
39011     } catch (std::exception& e) {
39012       {
39013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39014       };
39015     } catch (Dali::DaliException e) {
39016       {
39017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39018       };
39019     } catch (...) {
39020       {
39021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39022       };
39023     }
39024   }
39025
39026   jresult = (void *)result;
39027   return jresult;
39028 }
39029
39030
39031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
39032   void * jresult ;
39033   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39034   Dali::Stage::TouchSignalType *result = 0 ;
39035
39036   arg1 = (Dali::Stage *)jarg1;
39037   {
39038     try {
39039       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
39040     } catch (std::out_of_range& e) {
39041       {
39042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39043       };
39044     } catch (std::exception& e) {
39045       {
39046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39047       };
39048     } catch (Dali::DaliException e) {
39049       {
39050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39051       };
39052     } catch (...) {
39053       {
39054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39055       };
39056     }
39057   }
39058
39059   jresult = (void *)result;
39060   return jresult;
39061 }
39062
39063
39064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
39065   void * jresult ;
39066   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39067   Dali::Stage::WheelEventSignalType *result = 0 ;
39068
39069   arg1 = (Dali::Stage *)jarg1;
39070   {
39071     try {
39072       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
39073     } catch (std::out_of_range& e) {
39074       {
39075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39076       };
39077     } catch (std::exception& e) {
39078       {
39079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39080       };
39081     } catch (Dali::DaliException e) {
39082       {
39083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39084       };
39085     } catch (...) {
39086       {
39087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39088       };
39089     }
39090   }
39091
39092   jresult = (void *)result;
39093   return jresult;
39094 }
39095
39096
39097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
39098   void * jresult ;
39099   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39100   Dali::Stage::ContextStatusSignal *result = 0 ;
39101
39102   arg1 = (Dali::Stage *)jarg1;
39103   {
39104     try {
39105       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
39106     } catch (std::out_of_range& e) {
39107       {
39108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39109       };
39110     } catch (std::exception& e) {
39111       {
39112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39113       };
39114     } catch (Dali::DaliException e) {
39115       {
39116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39117       };
39118     } catch (...) {
39119       {
39120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39121       };
39122     }
39123   }
39124
39125   jresult = (void *)result;
39126   return jresult;
39127 }
39128
39129
39130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
39131   void * jresult ;
39132   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39133   Dali::Stage::ContextStatusSignal *result = 0 ;
39134
39135   arg1 = (Dali::Stage *)jarg1;
39136   {
39137     try {
39138       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
39139     } catch (std::out_of_range& e) {
39140       {
39141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39142       };
39143     } catch (std::exception& e) {
39144       {
39145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39146       };
39147     } catch (Dali::DaliException e) {
39148       {
39149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39150       };
39151     } catch (...) {
39152       {
39153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39154       };
39155     }
39156   }
39157
39158   jresult = (void *)result;
39159   return jresult;
39160 }
39161
39162
39163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
39164   void * jresult ;
39165   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39166   Dali::Stage::SceneCreatedSignalType *result = 0 ;
39167
39168   arg1 = (Dali::Stage *)jarg1;
39169   {
39170     try {
39171       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
39172     } catch (std::out_of_range& e) {
39173       {
39174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39175       };
39176     } catch (std::exception& e) {
39177       {
39178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39179       };
39180     } catch (Dali::DaliException e) {
39181       {
39182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39183       };
39184     } catch (...) {
39185       {
39186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39187       };
39188     }
39189   }
39190
39191   jresult = (void *)result;
39192   return jresult;
39193 }
39194
39195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
39196   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39197   Dali::DevelStage::Rendering arg2 ;
39198
39199   arg1 = (Dali::Stage *)jarg1;
39200   arg2 = (Dali::DevelStage::Rendering)jarg2;
39201   {
39202     try {
39203       DevelStage::SetRenderingBehavior(*arg1,arg2);
39204     } catch (std::out_of_range& e) {
39205       {
39206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39207       };
39208     } catch (std::exception& e) {
39209       {
39210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39211       };
39212     } catch (Dali::DaliException e) {
39213       {
39214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39215       };
39216     } catch (...) {
39217       {
39218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39219       };
39220     }
39221   }
39222
39223 }
39224
39225 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
39226
39227   int jresult ;
39228   int result ;
39229   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
39230
39231   arg1 = (Dali::Stage *)jarg1;
39232   {
39233     try {
39234       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
39235     } catch (std::out_of_range& e) {
39236       {
39237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39238       };
39239     } catch (std::exception& e) {
39240       {
39241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39242       };
39243     } catch (Dali::DaliException e) {
39244       {
39245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39246       };
39247     } catch (...) {
39248       {
39249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39250       };
39251     }
39252   }
39253
39254   jresult = result;
39255   return jresult;
39256 }
39257
39258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
39259   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39260
39261   arg1 = (Dali::RelayoutContainer *)jarg1;
39262   {
39263     try {
39264       delete arg1;
39265     } catch (std::out_of_range& e) {
39266       {
39267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39268       };
39269     } catch (std::exception& e) {
39270       {
39271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39272       };
39273     } catch (Dali::DaliException e) {
39274       {
39275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39276       };
39277     } catch (...) {
39278       {
39279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39280       };
39281     }
39282   }
39283
39284 }
39285
39286
39287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
39288   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
39289   Dali::Actor *arg2 = 0 ;
39290   Dali::Vector2 *arg3 = 0 ;
39291
39292   arg1 = (Dali::RelayoutContainer *)jarg1;
39293   arg2 = (Dali::Actor *)jarg2;
39294   if (!arg2) {
39295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39296     return ;
39297   }
39298   arg3 = (Dali::Vector2 *)jarg3;
39299   if (!arg3) {
39300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39301     return ;
39302   }
39303   {
39304     try {
39305       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
39306     } catch (std::out_of_range& e) {
39307       {
39308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39309       };
39310     } catch (std::exception& e) {
39311       {
39312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39313       };
39314     } catch (Dali::DaliException e) {
39315       {
39316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39317       };
39318     } catch (...) {
39319       {
39320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39321       };
39322     }
39323   }
39324
39325 }
39326
39327
39328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
39329   void * jresult ;
39330   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39331   Dali::CustomActor result;
39332
39333   arg1 = (Dali::CustomActorImpl *)jarg1;
39334   {
39335     try {
39336       result = ((Dali::CustomActorImpl const *)arg1)->Self();
39337     } catch (std::out_of_range& e) {
39338       {
39339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39340       };
39341     } catch (std::exception& e) {
39342       {
39343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39344       };
39345     } catch (Dali::DaliException e) {
39346       {
39347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39348       };
39349     } catch (...) {
39350       {
39351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39352       };
39353     }
39354   }
39355
39356   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39357   return jresult;
39358 }
39359
39360
39361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
39362   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39363   int arg2 ;
39364
39365   arg1 = (Dali::CustomActorImpl *)jarg1;
39366   arg2 = (int)jarg2;
39367   {
39368     try {
39369       (arg1)->OnStageConnection(arg2);
39370     } catch (std::out_of_range& e) {
39371       {
39372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39373       };
39374     } catch (std::exception& e) {
39375       {
39376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39377       };
39378     } catch (Dali::DaliException e) {
39379       {
39380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39381       };
39382     } catch (...) {
39383       {
39384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39385       };
39386     }
39387   }
39388
39389 }
39390
39391
39392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
39393   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39394
39395   arg1 = (Dali::CustomActorImpl *)jarg1;
39396   {
39397     try {
39398       (arg1)->OnStageDisconnection();
39399     } catch (std::out_of_range& e) {
39400       {
39401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39402       };
39403     } catch (std::exception& e) {
39404       {
39405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39406       };
39407     } catch (Dali::DaliException e) {
39408       {
39409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39410       };
39411     } catch (...) {
39412       {
39413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39414       };
39415     }
39416   }
39417
39418 }
39419
39420
39421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39422   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39423   Dali::Actor *arg2 = 0 ;
39424
39425   arg1 = (Dali::CustomActorImpl *)jarg1;
39426   arg2 = (Dali::Actor *)jarg2;
39427   if (!arg2) {
39428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39429     return ;
39430   }
39431   {
39432     try {
39433       (arg1)->OnChildAdd(*arg2);
39434     } catch (std::out_of_range& e) {
39435       {
39436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39437       };
39438     } catch (std::exception& e) {
39439       {
39440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39441       };
39442     } catch (Dali::DaliException e) {
39443       {
39444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39445       };
39446     } catch (...) {
39447       {
39448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39449       };
39450     }
39451   }
39452
39453 }
39454
39455
39456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39457   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39458   Dali::Actor *arg2 = 0 ;
39459
39460   arg1 = (Dali::CustomActorImpl *)jarg1;
39461   arg2 = (Dali::Actor *)jarg2;
39462   if (!arg2) {
39463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39464     return ;
39465   }
39466   {
39467     try {
39468       (arg1)->OnChildRemove(*arg2);
39469     } catch (std::out_of_range& e) {
39470       {
39471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39472       };
39473     } catch (std::exception& e) {
39474       {
39475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39476       };
39477     } catch (Dali::DaliException e) {
39478       {
39479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39480       };
39481     } catch (...) {
39482       {
39483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39484       };
39485     }
39486   }
39487
39488 }
39489
39490
39491 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39492   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39493   Dali::Property::Index arg2 ;
39494   Dali::Property::Value arg3 ;
39495   Dali::Property::Value *argp3 ;
39496
39497   arg1 = (Dali::CustomActorImpl *)jarg1;
39498   arg2 = (Dali::Property::Index)jarg2;
39499   argp3 = (Dali::Property::Value *)jarg3;
39500   if (!argp3) {
39501     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39502     return ;
39503   }
39504   arg3 = *argp3;
39505   {
39506     try {
39507       (arg1)->OnPropertySet(arg2,arg3);
39508     } catch (std::out_of_range& e) {
39509       {
39510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39511       };
39512     } catch (std::exception& e) {
39513       {
39514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39515       };
39516     } catch (Dali::DaliException e) {
39517       {
39518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39519       };
39520     } catch (...) {
39521       {
39522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39523       };
39524     }
39525   }
39526
39527 }
39528
39529
39530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39531   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39532   Dali::Vector3 *arg2 = 0 ;
39533
39534   arg1 = (Dali::CustomActorImpl *)jarg1;
39535   arg2 = (Dali::Vector3 *)jarg2;
39536   if (!arg2) {
39537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39538     return ;
39539   }
39540   {
39541     try {
39542       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39543     } catch (std::out_of_range& e) {
39544       {
39545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39546       };
39547     } catch (std::exception& e) {
39548       {
39549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39550       };
39551     } catch (Dali::DaliException e) {
39552       {
39553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39554       };
39555     } catch (...) {
39556       {
39557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39558       };
39559     }
39560   }
39561
39562 }
39563
39564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39565   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39566   Dali::Animation *arg2 = 0 ;
39567   Dali::Vector3 *arg3 = 0 ;
39568
39569   arg1 = (Dali::CustomActorImpl *)jarg1;
39570   arg2 = (Dali::Animation *)jarg2;
39571   if (!arg2) {
39572     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39573     return ;
39574   }
39575   arg3 = (Dali::Vector3 *)jarg3;
39576   if (!arg3) {
39577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39578     return ;
39579   }
39580   {
39581     try {
39582       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39583     } catch (std::out_of_range& e) {
39584       {
39585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39586       };
39587     } catch (std::exception& e) {
39588       {
39589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39590       };
39591     } catch (Dali::DaliException e) {
39592       {
39593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39594       };
39595     } catch (...) {
39596       {
39597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39598       };
39599     }
39600   }
39601
39602 }
39603
39604
39605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39606   unsigned int jresult ;
39607   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39608   Dali::TouchEvent *arg2 = 0 ;
39609   bool result;
39610
39611   arg1 = (Dali::CustomActorImpl *)jarg1;
39612   arg2 = (Dali::TouchEvent *)jarg2;
39613   if (!arg2) {
39614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39615     return 0;
39616   }
39617   {
39618     try {
39619       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39620     } catch (std::out_of_range& e) {
39621       {
39622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39623       };
39624     } catch (std::exception& e) {
39625       {
39626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39627       };
39628     } catch (Dali::DaliException e) {
39629       {
39630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39631       };
39632     } catch (...) {
39633       {
39634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39635       };
39636     }
39637   }
39638
39639   jresult = result;
39640   return jresult;
39641 }
39642
39643
39644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39645   unsigned int jresult ;
39646   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39647   Dali::HoverEvent *arg2 = 0 ;
39648   bool result;
39649
39650   arg1 = (Dali::CustomActorImpl *)jarg1;
39651   arg2 = (Dali::HoverEvent *)jarg2;
39652   if (!arg2) {
39653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39654     return 0;
39655   }
39656   {
39657     try {
39658       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39659     } catch (std::out_of_range& e) {
39660       {
39661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39662       };
39663     } catch (std::exception& e) {
39664       {
39665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39666       };
39667     } catch (Dali::DaliException e) {
39668       {
39669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39670       };
39671     } catch (...) {
39672       {
39673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39674       };
39675     }
39676   }
39677
39678   jresult = result;
39679   return jresult;
39680 }
39681
39682
39683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39684   unsigned int jresult ;
39685   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39686   Dali::KeyEvent *arg2 = 0 ;
39687   bool result;
39688
39689   arg1 = (Dali::CustomActorImpl *)jarg1;
39690   arg2 = (Dali::KeyEvent *)jarg2;
39691   if (!arg2) {
39692     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39693     return 0;
39694   }
39695   {
39696     try {
39697       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39698     } catch (std::out_of_range& e) {
39699       {
39700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39701       };
39702     } catch (std::exception& e) {
39703       {
39704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39705       };
39706     } catch (Dali::DaliException e) {
39707       {
39708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39709       };
39710     } catch (...) {
39711       {
39712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39713       };
39714     }
39715   }
39716
39717   jresult = result;
39718   return jresult;
39719 }
39720
39721
39722 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39723   unsigned int jresult ;
39724   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39725   Dali::WheelEvent *arg2 = 0 ;
39726   bool result;
39727
39728   arg1 = (Dali::CustomActorImpl *)jarg1;
39729   arg2 = (Dali::WheelEvent *)jarg2;
39730   if (!arg2) {
39731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39732     return 0;
39733   }
39734   {
39735     try {
39736       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39737     } catch (std::out_of_range& e) {
39738       {
39739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39740       };
39741     } catch (std::exception& e) {
39742       {
39743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39744       };
39745     } catch (Dali::DaliException e) {
39746       {
39747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39748       };
39749     } catch (...) {
39750       {
39751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39752       };
39753     }
39754   }
39755
39756   jresult = result;
39757   return jresult;
39758 }
39759
39760
39761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39762   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39763   Dali::Vector2 *arg2 = 0 ;
39764   Dali::RelayoutContainer *arg3 = 0 ;
39765
39766   arg1 = (Dali::CustomActorImpl *)jarg1;
39767   arg2 = (Dali::Vector2 *)jarg2;
39768   if (!arg2) {
39769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39770     return ;
39771   }
39772   arg3 = (Dali::RelayoutContainer *)jarg3;
39773   if (!arg3) {
39774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39775     return ;
39776   }
39777   {
39778     try {
39779       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39780     } catch (std::out_of_range& e) {
39781       {
39782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39783       };
39784     } catch (std::exception& e) {
39785       {
39786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39787       };
39788     } catch (Dali::DaliException e) {
39789       {
39790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39791       };
39792     } catch (...) {
39793       {
39794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39795       };
39796     }
39797   }
39798
39799 }
39800
39801
39802 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39803   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39804   Dali::ResizePolicy::Type arg2 ;
39805   Dali::Dimension::Type arg3 ;
39806
39807   arg1 = (Dali::CustomActorImpl *)jarg1;
39808   arg2 = (Dali::ResizePolicy::Type)jarg2;
39809   arg3 = (Dali::Dimension::Type)jarg3;
39810   {
39811     try {
39812       (arg1)->OnSetResizePolicy(arg2,arg3);
39813     } catch (std::out_of_range& e) {
39814       {
39815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39816       };
39817     } catch (std::exception& e) {
39818       {
39819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39820       };
39821     } catch (Dali::DaliException e) {
39822       {
39823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39824       };
39825     } catch (...) {
39826       {
39827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39828       };
39829     }
39830   }
39831
39832 }
39833
39834
39835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39836   void * jresult ;
39837   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39838   Dali::Vector3 result;
39839
39840   arg1 = (Dali::CustomActorImpl *)jarg1;
39841   {
39842     try {
39843       result = (arg1)->GetNaturalSize();
39844     } catch (std::out_of_range& e) {
39845       {
39846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39847       };
39848     } catch (std::exception& e) {
39849       {
39850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39851       };
39852     } catch (Dali::DaliException e) {
39853       {
39854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39855       };
39856     } catch (...) {
39857       {
39858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39859       };
39860     }
39861   }
39862
39863   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39864   return jresult;
39865 }
39866
39867
39868 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39869   float jresult ;
39870   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39871   Dali::Actor *arg2 = 0 ;
39872   Dali::Dimension::Type arg3 ;
39873   float result;
39874
39875   arg1 = (Dali::CustomActorImpl *)jarg1;
39876   arg2 = (Dali::Actor *)jarg2;
39877   if (!arg2) {
39878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39879     return 0;
39880   }
39881   arg3 = (Dali::Dimension::Type)jarg3;
39882   {
39883     try {
39884       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39885     } catch (std::out_of_range& e) {
39886       {
39887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39888       };
39889     } catch (std::exception& e) {
39890       {
39891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39892       };
39893     } catch (Dali::DaliException e) {
39894       {
39895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39896       };
39897     } catch (...) {
39898       {
39899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39900       };
39901     }
39902   }
39903
39904   jresult = result;
39905   return jresult;
39906 }
39907
39908
39909 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39910   float jresult ;
39911   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39912   float arg2 ;
39913   float result;
39914
39915   arg1 = (Dali::CustomActorImpl *)jarg1;
39916   arg2 = (float)jarg2;
39917   {
39918     try {
39919       result = (float)(arg1)->GetHeightForWidth(arg2);
39920     } catch (std::out_of_range& e) {
39921       {
39922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39923       };
39924     } catch (std::exception& e) {
39925       {
39926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39927       };
39928     } catch (Dali::DaliException e) {
39929       {
39930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39931       };
39932     } catch (...) {
39933       {
39934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39935       };
39936     }
39937   }
39938
39939   jresult = result;
39940   return jresult;
39941 }
39942
39943
39944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39945   float jresult ;
39946   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39947   float arg2 ;
39948   float result;
39949
39950   arg1 = (Dali::CustomActorImpl *)jarg1;
39951   arg2 = (float)jarg2;
39952   {
39953     try {
39954       result = (float)(arg1)->GetWidthForHeight(arg2);
39955     } catch (std::out_of_range& e) {
39956       {
39957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39958       };
39959     } catch (std::exception& e) {
39960       {
39961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39962       };
39963     } catch (Dali::DaliException e) {
39964       {
39965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39966       };
39967     } catch (...) {
39968       {
39969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39970       };
39971     }
39972   }
39973
39974   jresult = result;
39975   return jresult;
39976 }
39977
39978
39979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39980   unsigned int jresult ;
39981   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39982   Dali::Dimension::Type arg2 ;
39983   bool result;
39984
39985   arg1 = (Dali::CustomActorImpl *)jarg1;
39986   arg2 = (Dali::Dimension::Type)jarg2;
39987   {
39988     try {
39989       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39990     } catch (std::out_of_range& e) {
39991       {
39992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39993       };
39994     } catch (std::exception& e) {
39995       {
39996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39997       };
39998     } catch (Dali::DaliException e) {
39999       {
40000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40001       };
40002     } catch (...) {
40003       {
40004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40005       };
40006     }
40007   }
40008
40009   jresult = result;
40010   return jresult;
40011 }
40012
40013
40014 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
40015   unsigned int jresult ;
40016   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40017   bool result;
40018
40019   arg1 = (Dali::CustomActorImpl *)jarg1;
40020   {
40021     try {
40022       result = (bool)(arg1)->RelayoutDependentOnChildren();
40023     } catch (std::out_of_range& e) {
40024       {
40025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40026       };
40027     } catch (std::exception& e) {
40028       {
40029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40030       };
40031     } catch (Dali::DaliException e) {
40032       {
40033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40034       };
40035     } catch (...) {
40036       {
40037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40038       };
40039     }
40040   }
40041
40042   jresult = result;
40043   return jresult;
40044 }
40045
40046
40047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
40048   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40049   Dali::Dimension::Type arg2 ;
40050
40051   arg1 = (Dali::CustomActorImpl *)jarg1;
40052   arg2 = (Dali::Dimension::Type)jarg2;
40053   {
40054     try {
40055       (arg1)->OnCalculateRelayoutSize(arg2);
40056     } catch (std::out_of_range& e) {
40057       {
40058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40059       };
40060     } catch (std::exception& e) {
40061       {
40062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40063       };
40064     } catch (Dali::DaliException e) {
40065       {
40066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40067       };
40068     } catch (...) {
40069       {
40070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40071       };
40072     }
40073   }
40074
40075 }
40076
40077
40078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
40079   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40080   float arg2 ;
40081   Dali::Dimension::Type arg3 ;
40082
40083   arg1 = (Dali::CustomActorImpl *)jarg1;
40084   arg2 = (float)jarg2;
40085   arg3 = (Dali::Dimension::Type)jarg3;
40086   {
40087     try {
40088       (arg1)->OnLayoutNegotiated(arg2,arg3);
40089     } catch (std::out_of_range& e) {
40090       {
40091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40092       };
40093     } catch (std::exception& e) {
40094       {
40095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40096       };
40097     } catch (Dali::DaliException e) {
40098       {
40099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40100       };
40101     } catch (...) {
40102       {
40103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40104       };
40105     }
40106   }
40107
40108 }
40109
40110
40111 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
40112   unsigned int jresult ;
40113   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40114   bool result;
40115
40116   arg1 = (Dali::CustomActorImpl *)jarg1;
40117   {
40118     try {
40119       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
40120     } catch (std::out_of_range& e) {
40121       {
40122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40123       };
40124     } catch (std::exception& e) {
40125       {
40126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40127       };
40128     } catch (Dali::DaliException e) {
40129       {
40130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40131       };
40132     } catch (...) {
40133       {
40134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40135       };
40136     }
40137   }
40138
40139   jresult = result;
40140   return jresult;
40141 }
40142
40143
40144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
40145   unsigned int jresult ;
40146   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40147   bool result;
40148
40149   arg1 = (Dali::CustomActorImpl *)jarg1;
40150   {
40151     try {
40152       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
40153     } catch (std::out_of_range& e) {
40154       {
40155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40156       };
40157     } catch (std::exception& e) {
40158       {
40159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40160       };
40161     } catch (Dali::DaliException e) {
40162       {
40163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40164       };
40165     } catch (...) {
40166       {
40167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40168       };
40169     }
40170   }
40171
40172   jresult = result;
40173   return jresult;
40174 }
40175
40176
40177 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
40178   unsigned int jresult ;
40179   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40180   bool result;
40181
40182   arg1 = (Dali::CustomActorImpl *)jarg1;
40183   {
40184     try {
40185       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
40186     } catch (std::out_of_range& e) {
40187       {
40188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40189       };
40190     } catch (std::exception& e) {
40191       {
40192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40193       };
40194     } catch (Dali::DaliException e) {
40195       {
40196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40197       };
40198     } catch (...) {
40199       {
40200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40201       };
40202     }
40203   }
40204
40205   jresult = result;
40206   return jresult;
40207 }
40208
40209
40210 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
40211   unsigned int jresult ;
40212   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
40213   bool result;
40214
40215   arg1 = (Dali::CustomActorImpl *)jarg1;
40216   {
40217     try {
40218       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
40219     } catch (std::out_of_range& e) {
40220       {
40221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40222       };
40223     } catch (std::exception& e) {
40224       {
40225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40226       };
40227     } catch (Dali::DaliException e) {
40228       {
40229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40230       };
40231     } catch (...) {
40232       {
40233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40234       };
40235     }
40236   }
40237
40238   jresult = result;
40239   return jresult;
40240 }
40241
40242
40243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
40244   void * jresult ;
40245   Dali::CustomActor *result = 0 ;
40246
40247   {
40248     try {
40249       result = (Dali::CustomActor *)new Dali::CustomActor();
40250     } catch (std::out_of_range& e) {
40251       {
40252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40253       };
40254     } catch (std::exception& e) {
40255       {
40256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40257       };
40258     } catch (Dali::DaliException e) {
40259       {
40260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40261       };
40262     } catch (...) {
40263       {
40264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40265       };
40266     }
40267   }
40268
40269   jresult = (void *)result;
40270   return jresult;
40271 }
40272
40273
40274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
40275   void * jresult ;
40276   Dali::BaseHandle arg1 ;
40277   Dali::BaseHandle *argp1 ;
40278   Dali::CustomActor result;
40279
40280   argp1 = (Dali::BaseHandle *)jarg1;
40281   if (!argp1) {
40282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40283     return 0;
40284   }
40285   arg1 = *argp1;
40286   {
40287     try {
40288       result = Dali::CustomActor::DownCast(arg1);
40289     } catch (std::out_of_range& e) {
40290       {
40291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40292       };
40293     } catch (std::exception& e) {
40294       {
40295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40296       };
40297     } catch (Dali::DaliException e) {
40298       {
40299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40300       };
40301     } catch (...) {
40302       {
40303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40304       };
40305     }
40306   }
40307
40308   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
40309   return jresult;
40310 }
40311
40312
40313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
40314   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40315
40316   arg1 = (Dali::CustomActor *)jarg1;
40317   {
40318     try {
40319       delete arg1;
40320     } catch (std::out_of_range& e) {
40321       {
40322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40323       };
40324     } catch (std::exception& e) {
40325       {
40326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40327       };
40328     } catch (Dali::DaliException e) {
40329       {
40330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40331       };
40332     } catch (...) {
40333       {
40334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40335       };
40336     }
40337   }
40338
40339 }
40340
40341
40342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
40343   void * jresult ;
40344   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40345   Dali::CustomActorImpl *result = 0 ;
40346
40347   arg1 = (Dali::CustomActor *)jarg1;
40348   {
40349     try {
40350       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
40351     } catch (std::out_of_range& e) {
40352       {
40353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40354       };
40355     } catch (std::exception& e) {
40356       {
40357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40358       };
40359     } catch (Dali::DaliException e) {
40360       {
40361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40362       };
40363     } catch (...) {
40364       {
40365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40366       };
40367     }
40368   }
40369
40370   jresult = (void *)result;
40371   return jresult;
40372 }
40373
40374
40375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
40376   void * jresult ;
40377   Dali::CustomActorImpl *arg1 = 0 ;
40378   Dali::CustomActor *result = 0 ;
40379
40380   arg1 = (Dali::CustomActorImpl *)jarg1;
40381   if (!arg1) {
40382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
40383     return 0;
40384   }
40385   {
40386     try {
40387       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
40388     } catch (std::out_of_range& e) {
40389       {
40390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40391       };
40392     } catch (std::exception& e) {
40393       {
40394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40395       };
40396     } catch (Dali::DaliException e) {
40397       {
40398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40399       };
40400     } catch (...) {
40401       {
40402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40403       };
40404     }
40405   }
40406
40407   jresult = (void *)result;
40408   return jresult;
40409 }
40410
40411
40412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40413   void * jresult ;
40414   Dali::CustomActor *arg1 = 0 ;
40415   Dali::CustomActor *result = 0 ;
40416
40417   arg1 = (Dali::CustomActor *)jarg1;
40418   if (!arg1) {
40419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40420     return 0;
40421   }
40422   {
40423     try {
40424       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40425     } catch (std::out_of_range& e) {
40426       {
40427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40428       };
40429     } catch (std::exception& e) {
40430       {
40431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40432       };
40433     } catch (Dali::DaliException e) {
40434       {
40435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40436       };
40437     } catch (...) {
40438       {
40439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40440       };
40441     }
40442   }
40443
40444   jresult = (void *)result;
40445   return jresult;
40446 }
40447
40448
40449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40450   void * jresult ;
40451   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40452   Dali::CustomActor *arg2 = 0 ;
40453   Dali::CustomActor *result = 0 ;
40454
40455   arg1 = (Dali::CustomActor *)jarg1;
40456   arg2 = (Dali::CustomActor *)jarg2;
40457   if (!arg2) {
40458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40459     return 0;
40460   }
40461   {
40462     try {
40463       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40464     } catch (std::out_of_range& e) {
40465       {
40466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40467       };
40468     } catch (std::exception& e) {
40469       {
40470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40471       };
40472     } catch (Dali::DaliException e) {
40473       {
40474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40475       };
40476     } catch (...) {
40477       {
40478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40479       };
40480     }
40481   }
40482
40483   jresult = (void *)result;
40484   return jresult;
40485 }
40486
40487
40488 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40489   int jresult ;
40490   int result;
40491
40492   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40493   jresult = (int)result;
40494   return jresult;
40495 }
40496
40497
40498 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40499   int jresult ;
40500   int result;
40501
40502   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40503   jresult = (int)result;
40504   return jresult;
40505 }
40506
40507
40508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40509   int jresult ;
40510   int result;
40511
40512   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40513   jresult = (int)result;
40514   return jresult;
40515 }
40516
40517
40518 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40519   int jresult ;
40520   int result;
40521
40522   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40523   jresult = (int)result;
40524   return jresult;
40525 }
40526
40527
40528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40529   int jresult ;
40530   int result;
40531
40532   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40533   jresult = (int)result;
40534   return jresult;
40535 }
40536
40537
40538 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40539   int jresult ;
40540   int result;
40541
40542   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40543   jresult = (int)result;
40544   return jresult;
40545 }
40546
40547
40548 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40549   int jresult ;
40550   int result;
40551
40552   result = (int)Dali::PanGestureDetector::Property::PANNING;
40553   jresult = (int)result;
40554   return jresult;
40555 }
40556
40557
40558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40559   void * jresult ;
40560   Dali::PanGestureDetector::Property *result = 0 ;
40561
40562   {
40563     try {
40564       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40565     } catch (std::out_of_range& e) {
40566       {
40567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40568       };
40569     } catch (std::exception& e) {
40570       {
40571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40572       };
40573     } catch (Dali::DaliException e) {
40574       {
40575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40576       };
40577     } catch (...) {
40578       {
40579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40580       };
40581     }
40582   }
40583
40584   jresult = (void *)result;
40585   return jresult;
40586 }
40587
40588
40589 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40590   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40591
40592   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40593   {
40594     try {
40595       delete arg1;
40596     } catch (std::out_of_range& e) {
40597       {
40598         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40599       };
40600     } catch (std::exception& e) {
40601       {
40602         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40603       };
40604     } catch (Dali::DaliException e) {
40605       {
40606         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40607       };
40608     } catch (...) {
40609       {
40610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40611       };
40612     }
40613   }
40614
40615 }
40616
40617
40618 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40619   void * jresult ;
40620   Dali::Radian *result = 0 ;
40621
40622   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40623   jresult = (void *)result;
40624   return jresult;
40625 }
40626
40627
40628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40629   void * jresult ;
40630   Dali::Radian *result = 0 ;
40631
40632   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40633   jresult = (void *)result;
40634   return jresult;
40635 }
40636
40637
40638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40639   void * jresult ;
40640   Dali::Radian *result = 0 ;
40641
40642   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40643   jresult = (void *)result;
40644   return jresult;
40645 }
40646
40647
40648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40649   void * jresult ;
40650   Dali::Radian *result = 0 ;
40651
40652   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40653   jresult = (void *)result;
40654   return jresult;
40655 }
40656
40657
40658 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40659   void * jresult ;
40660   Dali::Radian *result = 0 ;
40661
40662   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40663   jresult = (void *)result;
40664   return jresult;
40665 }
40666
40667
40668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40669   void * jresult ;
40670   Dali::Radian *result = 0 ;
40671
40672   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40673   jresult = (void *)result;
40674   return jresult;
40675 }
40676
40677
40678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40679   void * jresult ;
40680   Dali::Radian *result = 0 ;
40681
40682   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40683   jresult = (void *)result;
40684   return jresult;
40685 }
40686
40687
40688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40689   void * jresult ;
40690   Dali::PanGestureDetector *result = 0 ;
40691
40692   {
40693     try {
40694       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40695     } catch (std::out_of_range& e) {
40696       {
40697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40698       };
40699     } catch (std::exception& e) {
40700       {
40701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40702       };
40703     } catch (Dali::DaliException e) {
40704       {
40705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40706       };
40707     } catch (...) {
40708       {
40709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40710       };
40711     }
40712   }
40713
40714   jresult = (void *)result;
40715   return jresult;
40716 }
40717
40718
40719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40720   void * jresult ;
40721   Dali::PanGestureDetector result;
40722
40723   {
40724     try {
40725       result = Dali::PanGestureDetector::New();
40726     } catch (std::out_of_range& e) {
40727       {
40728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40729       };
40730     } catch (std::exception& e) {
40731       {
40732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40733       };
40734     } catch (Dali::DaliException e) {
40735       {
40736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40737       };
40738     } catch (...) {
40739       {
40740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40741       };
40742     }
40743   }
40744
40745   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40746   return jresult;
40747 }
40748
40749
40750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40751   void * jresult ;
40752   Dali::BaseHandle arg1 ;
40753   Dali::BaseHandle *argp1 ;
40754   Dali::PanGestureDetector result;
40755
40756   argp1 = (Dali::BaseHandle *)jarg1;
40757   if (!argp1) {
40758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40759     return 0;
40760   }
40761   arg1 = *argp1;
40762   {
40763     try {
40764       result = Dali::PanGestureDetector::DownCast(arg1);
40765     } catch (std::out_of_range& e) {
40766       {
40767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40768       };
40769     } catch (std::exception& e) {
40770       {
40771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40772       };
40773     } catch (Dali::DaliException e) {
40774       {
40775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40776       };
40777     } catch (...) {
40778       {
40779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40780       };
40781     }
40782   }
40783
40784   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40785   return jresult;
40786 }
40787
40788
40789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40790   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40791
40792   arg1 = (Dali::PanGestureDetector *)jarg1;
40793   {
40794     try {
40795       delete arg1;
40796     } catch (std::out_of_range& e) {
40797       {
40798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40799       };
40800     } catch (std::exception& e) {
40801       {
40802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40803       };
40804     } catch (Dali::DaliException e) {
40805       {
40806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40807       };
40808     } catch (...) {
40809       {
40810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40811       };
40812     }
40813   }
40814
40815 }
40816
40817
40818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40819   void * jresult ;
40820   Dali::PanGestureDetector *arg1 = 0 ;
40821   Dali::PanGestureDetector *result = 0 ;
40822
40823   arg1 = (Dali::PanGestureDetector *)jarg1;
40824   if (!arg1) {
40825     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40826     return 0;
40827   }
40828   {
40829     try {
40830       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40831     } catch (std::out_of_range& e) {
40832       {
40833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40834       };
40835     } catch (std::exception& e) {
40836       {
40837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40838       };
40839     } catch (Dali::DaliException e) {
40840       {
40841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40842       };
40843     } catch (...) {
40844       {
40845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40846       };
40847     }
40848   }
40849
40850   jresult = (void *)result;
40851   return jresult;
40852 }
40853
40854
40855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40856   void * jresult ;
40857   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40858   Dali::PanGestureDetector *arg2 = 0 ;
40859   Dali::PanGestureDetector *result = 0 ;
40860
40861   arg1 = (Dali::PanGestureDetector *)jarg1;
40862   arg2 = (Dali::PanGestureDetector *)jarg2;
40863   if (!arg2) {
40864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40865     return 0;
40866   }
40867   {
40868     try {
40869       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40870     } catch (std::out_of_range& e) {
40871       {
40872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40873       };
40874     } catch (std::exception& e) {
40875       {
40876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40877       };
40878     } catch (Dali::DaliException e) {
40879       {
40880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40881       };
40882     } catch (...) {
40883       {
40884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40885       };
40886     }
40887   }
40888
40889   jresult = (void *)result;
40890   return jresult;
40891 }
40892
40893
40894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40895   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40896   unsigned int arg2 ;
40897
40898   arg1 = (Dali::PanGestureDetector *)jarg1;
40899   arg2 = (unsigned int)jarg2;
40900   {
40901     try {
40902       (arg1)->SetMinimumTouchesRequired(arg2);
40903     } catch (std::out_of_range& e) {
40904       {
40905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40906       };
40907     } catch (std::exception& e) {
40908       {
40909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40910       };
40911     } catch (Dali::DaliException e) {
40912       {
40913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40914       };
40915     } catch (...) {
40916       {
40917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40918       };
40919     }
40920   }
40921
40922 }
40923
40924
40925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40926   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40927   unsigned int arg2 ;
40928
40929   arg1 = (Dali::PanGestureDetector *)jarg1;
40930   arg2 = (unsigned int)jarg2;
40931   {
40932     try {
40933       (arg1)->SetMaximumTouchesRequired(arg2);
40934     } catch (std::out_of_range& e) {
40935       {
40936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40937       };
40938     } catch (std::exception& e) {
40939       {
40940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40941       };
40942     } catch (Dali::DaliException e) {
40943       {
40944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40945       };
40946     } catch (...) {
40947       {
40948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40949       };
40950     }
40951   }
40952
40953 }
40954
40955
40956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40957   unsigned int jresult ;
40958   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40959   unsigned int result;
40960
40961   arg1 = (Dali::PanGestureDetector *)jarg1;
40962   {
40963     try {
40964       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40965     } catch (std::out_of_range& e) {
40966       {
40967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40968       };
40969     } catch (std::exception& e) {
40970       {
40971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40972       };
40973     } catch (Dali::DaliException e) {
40974       {
40975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40976       };
40977     } catch (...) {
40978       {
40979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40980       };
40981     }
40982   }
40983
40984   jresult = result;
40985   return jresult;
40986 }
40987
40988
40989 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40990   unsigned int jresult ;
40991   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40992   unsigned int result;
40993
40994   arg1 = (Dali::PanGestureDetector *)jarg1;
40995   {
40996     try {
40997       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40998     } catch (std::out_of_range& e) {
40999       {
41000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41001       };
41002     } catch (std::exception& e) {
41003       {
41004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41005       };
41006     } catch (Dali::DaliException e) {
41007       {
41008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41009       };
41010     } catch (...) {
41011       {
41012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41013       };
41014     }
41015   }
41016
41017   jresult = result;
41018   return jresult;
41019 }
41020
41021
41022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41023   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41024   Dali::Radian arg2 ;
41025   Dali::Radian arg3 ;
41026   Dali::Radian *argp2 ;
41027   Dali::Radian *argp3 ;
41028
41029   arg1 = (Dali::PanGestureDetector *)jarg1;
41030   argp2 = (Dali::Radian *)jarg2;
41031   if (!argp2) {
41032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41033     return ;
41034   }
41035   arg2 = *argp2;
41036   argp3 = (Dali::Radian *)jarg3;
41037   if (!argp3) {
41038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41039     return ;
41040   }
41041   arg3 = *argp3;
41042   {
41043     try {
41044       (arg1)->AddAngle(arg2,arg3);
41045     } catch (std::out_of_range& e) {
41046       {
41047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41048       };
41049     } catch (std::exception& e) {
41050       {
41051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41052       };
41053     } catch (Dali::DaliException e) {
41054       {
41055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41056       };
41057     } catch (...) {
41058       {
41059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41060       };
41061     }
41062   }
41063
41064 }
41065
41066
41067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
41068   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41069   Dali::Radian arg2 ;
41070   Dali::Radian *argp2 ;
41071
41072   arg1 = (Dali::PanGestureDetector *)jarg1;
41073   argp2 = (Dali::Radian *)jarg2;
41074   if (!argp2) {
41075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41076     return ;
41077   }
41078   arg2 = *argp2;
41079   {
41080     try {
41081       (arg1)->AddAngle(arg2);
41082     } catch (std::out_of_range& e) {
41083       {
41084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41085       };
41086     } catch (std::exception& e) {
41087       {
41088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41089       };
41090     } catch (Dali::DaliException e) {
41091       {
41092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41093       };
41094     } catch (...) {
41095       {
41096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41097       };
41098     }
41099   }
41100
41101 }
41102
41103
41104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
41105   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41106   Dali::Radian arg2 ;
41107   Dali::Radian arg3 ;
41108   Dali::Radian *argp2 ;
41109   Dali::Radian *argp3 ;
41110
41111   arg1 = (Dali::PanGestureDetector *)jarg1;
41112   argp2 = (Dali::Radian *)jarg2;
41113   if (!argp2) {
41114     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41115     return ;
41116   }
41117   arg2 = *argp2;
41118   argp3 = (Dali::Radian *)jarg3;
41119   if (!argp3) {
41120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41121     return ;
41122   }
41123   arg3 = *argp3;
41124   {
41125     try {
41126       (arg1)->AddDirection(arg2,arg3);
41127     } catch (std::out_of_range& e) {
41128       {
41129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41130       };
41131     } catch (std::exception& e) {
41132       {
41133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41134       };
41135     } catch (Dali::DaliException e) {
41136       {
41137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41138       };
41139     } catch (...) {
41140       {
41141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41142       };
41143     }
41144   }
41145
41146 }
41147
41148
41149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
41150   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41151   Dali::Radian arg2 ;
41152   Dali::Radian *argp2 ;
41153
41154   arg1 = (Dali::PanGestureDetector *)jarg1;
41155   argp2 = (Dali::Radian *)jarg2;
41156   if (!argp2) {
41157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41158     return ;
41159   }
41160   arg2 = *argp2;
41161   {
41162     try {
41163       (arg1)->AddDirection(arg2);
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 (Dali::DaliException e) {
41173       {
41174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41175       };
41176     } catch (...) {
41177       {
41178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41179       };
41180     }
41181   }
41182
41183 }
41184
41185
41186 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
41187   unsigned long jresult ;
41188   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41189   size_t result;
41190
41191   arg1 = (Dali::PanGestureDetector *)jarg1;
41192   {
41193     try {
41194       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
41195     } catch (std::out_of_range& e) {
41196       {
41197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41198       };
41199     } catch (std::exception& e) {
41200       {
41201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41202       };
41203     } catch (Dali::DaliException e) {
41204       {
41205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41206       };
41207     } catch (...) {
41208       {
41209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41210       };
41211     }
41212   }
41213
41214   jresult = (unsigned long)result;
41215   return jresult;
41216 }
41217
41218
41219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
41220   void * jresult ;
41221   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41222   size_t arg2 ;
41223   Dali::PanGestureDetector::AngleThresholdPair result;
41224
41225   arg1 = (Dali::PanGestureDetector *)jarg1;
41226   arg2 = (size_t)jarg2;
41227   {
41228     try {
41229       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
41230     } catch (std::out_of_range& e) {
41231       {
41232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41233       };
41234     } catch (std::exception& e) {
41235       {
41236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41237       };
41238     } catch (Dali::DaliException e) {
41239       {
41240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41241       };
41242     } catch (...) {
41243       {
41244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41245       };
41246     }
41247   }
41248
41249   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
41250   return jresult;
41251 }
41252
41253
41254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
41255   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41256
41257   arg1 = (Dali::PanGestureDetector *)jarg1;
41258   {
41259     try {
41260       (arg1)->ClearAngles();
41261     } catch (std::out_of_range& e) {
41262       {
41263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41264       };
41265     } catch (std::exception& e) {
41266       {
41267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41268       };
41269     } catch (Dali::DaliException e) {
41270       {
41271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41272       };
41273     } catch (...) {
41274       {
41275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41276       };
41277     }
41278   }
41279
41280 }
41281
41282
41283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
41284   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41285   Dali::Radian arg2 ;
41286   Dali::Radian *argp2 ;
41287
41288   arg1 = (Dali::PanGestureDetector *)jarg1;
41289   argp2 = (Dali::Radian *)jarg2;
41290   if (!argp2) {
41291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41292     return ;
41293   }
41294   arg2 = *argp2;
41295   {
41296     try {
41297       (arg1)->RemoveAngle(arg2);
41298     } catch (std::out_of_range& e) {
41299       {
41300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41301       };
41302     } catch (std::exception& e) {
41303       {
41304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41305       };
41306     } catch (Dali::DaliException e) {
41307       {
41308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41309       };
41310     } catch (...) {
41311       {
41312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41313       };
41314     }
41315   }
41316
41317 }
41318
41319
41320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
41321   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41322   Dali::Radian arg2 ;
41323   Dali::Radian *argp2 ;
41324
41325   arg1 = (Dali::PanGestureDetector *)jarg1;
41326   argp2 = (Dali::Radian *)jarg2;
41327   if (!argp2) {
41328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
41329     return ;
41330   }
41331   arg2 = *argp2;
41332   {
41333     try {
41334       (arg1)->RemoveDirection(arg2);
41335     } catch (std::out_of_range& e) {
41336       {
41337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41338       };
41339     } catch (std::exception& e) {
41340       {
41341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41342       };
41343     } catch (Dali::DaliException e) {
41344       {
41345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41346       };
41347     } catch (...) {
41348       {
41349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41350       };
41351     }
41352   }
41353
41354 }
41355
41356
41357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
41358   void * jresult ;
41359   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
41360   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
41361
41362   arg1 = (Dali::PanGestureDetector *)jarg1;
41363   {
41364     try {
41365       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41366     } catch (std::out_of_range& e) {
41367       {
41368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41369       };
41370     } catch (std::exception& e) {
41371       {
41372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41373       };
41374     } catch (Dali::DaliException e) {
41375       {
41376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41377       };
41378     } catch (...) {
41379       {
41380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41381       };
41382     }
41383   }
41384
41385   jresult = (void *)result;
41386   return jresult;
41387 }
41388
41389
41390 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
41391   Dali::PanGesture *arg1 = 0 ;
41392
41393   arg1 = (Dali::PanGesture *)jarg1;
41394   if (!arg1) {
41395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41396     return ;
41397   }
41398   {
41399     try {
41400       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
41401     } catch (std::out_of_range& e) {
41402       {
41403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41404       };
41405     } catch (std::exception& e) {
41406       {
41407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41408       };
41409     } catch (Dali::DaliException e) {
41410       {
41411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41412       };
41413     } catch (...) {
41414       {
41415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41416       };
41417     }
41418   }
41419
41420 }
41421
41422
41423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41424   void * jresult ;
41425   Dali::PanGesture *result = 0 ;
41426
41427   {
41428     try {
41429       result = (Dali::PanGesture *)new Dali::PanGesture();
41430     } catch (std::out_of_range& e) {
41431       {
41432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41433       };
41434     } catch (std::exception& e) {
41435       {
41436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41437       };
41438     } catch (Dali::DaliException e) {
41439       {
41440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41441       };
41442     } catch (...) {
41443       {
41444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41445       };
41446     }
41447   }
41448
41449   jresult = (void *)result;
41450   return jresult;
41451 }
41452
41453
41454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41455   void * jresult ;
41456   Dali::Gesture::State arg1 ;
41457   Dali::PanGesture *result = 0 ;
41458
41459   arg1 = (Dali::Gesture::State)jarg1;
41460   {
41461     try {
41462       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41463     } catch (std::out_of_range& e) {
41464       {
41465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41466       };
41467     } catch (std::exception& e) {
41468       {
41469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41470       };
41471     } catch (Dali::DaliException e) {
41472       {
41473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41474       };
41475     } catch (...) {
41476       {
41477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41478       };
41479     }
41480   }
41481
41482   jresult = (void *)result;
41483   return jresult;
41484 }
41485
41486
41487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41488   void * jresult ;
41489   Dali::PanGesture *arg1 = 0 ;
41490   Dali::PanGesture *result = 0 ;
41491
41492   arg1 = (Dali::PanGesture *)jarg1;
41493   if (!arg1) {
41494     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41495     return 0;
41496   }
41497   {
41498     try {
41499       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41500     } catch (std::out_of_range& e) {
41501       {
41502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41503       };
41504     } catch (std::exception& e) {
41505       {
41506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41507       };
41508     } catch (Dali::DaliException e) {
41509       {
41510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41511       };
41512     } catch (...) {
41513       {
41514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41515       };
41516     }
41517   }
41518
41519   jresult = (void *)result;
41520   return jresult;
41521 }
41522
41523
41524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41525   void * jresult ;
41526   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41527   Dali::PanGesture *arg2 = 0 ;
41528   Dali::PanGesture *result = 0 ;
41529
41530   arg1 = (Dali::PanGesture *)jarg1;
41531   arg2 = (Dali::PanGesture *)jarg2;
41532   if (!arg2) {
41533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41534     return 0;
41535   }
41536   {
41537     try {
41538       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41539     } catch (std::out_of_range& e) {
41540       {
41541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41542       };
41543     } catch (std::exception& e) {
41544       {
41545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41546       };
41547     } catch (Dali::DaliException e) {
41548       {
41549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41550       };
41551     } catch (...) {
41552       {
41553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41554       };
41555     }
41556   }
41557
41558   jresult = (void *)result;
41559   return jresult;
41560 }
41561
41562
41563 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41564   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41565
41566   arg1 = (Dali::PanGesture *)jarg1;
41567   {
41568     try {
41569       delete arg1;
41570     } catch (std::out_of_range& e) {
41571       {
41572         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41573       };
41574     } catch (std::exception& e) {
41575       {
41576         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41577       };
41578     } catch (Dali::DaliException e) {
41579       {
41580         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41581       };
41582     } catch (...) {
41583       {
41584         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41585       };
41586     }
41587   }
41588
41589 }
41590
41591
41592 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41593   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41594   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41595
41596   arg1 = (Dali::PanGesture *)jarg1;
41597   arg2 = (Dali::Vector2 *)jarg2;
41598   if (arg1) (arg1)->velocity = *arg2;
41599 }
41600
41601
41602 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41603   void * jresult ;
41604   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41605   Dali::Vector2 *result = 0 ;
41606
41607   arg1 = (Dali::PanGesture *)jarg1;
41608   result = (Dali::Vector2 *)& ((arg1)->velocity);
41609   jresult = (void *)result;
41610   return jresult;
41611 }
41612
41613
41614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41615   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41616   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41617
41618   arg1 = (Dali::PanGesture *)jarg1;
41619   arg2 = (Dali::Vector2 *)jarg2;
41620   if (arg1) (arg1)->displacement = *arg2;
41621 }
41622
41623
41624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41625   void * jresult ;
41626   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41627   Dali::Vector2 *result = 0 ;
41628
41629   arg1 = (Dali::PanGesture *)jarg1;
41630   result = (Dali::Vector2 *)& ((arg1)->displacement);
41631   jresult = (void *)result;
41632   return jresult;
41633 }
41634
41635
41636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41637   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41638   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41639
41640   arg1 = (Dali::PanGesture *)jarg1;
41641   arg2 = (Dali::Vector2 *)jarg2;
41642   if (arg1) (arg1)->position = *arg2;
41643 }
41644
41645
41646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41647   void * jresult ;
41648   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41649   Dali::Vector2 *result = 0 ;
41650
41651   arg1 = (Dali::PanGesture *)jarg1;
41652   result = (Dali::Vector2 *)& ((arg1)->position);
41653   jresult = (void *)result;
41654   return jresult;
41655 }
41656
41657
41658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41659   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41660   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41661
41662   arg1 = (Dali::PanGesture *)jarg1;
41663   arg2 = (Dali::Vector2 *)jarg2;
41664   if (arg1) (arg1)->screenVelocity = *arg2;
41665 }
41666
41667
41668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41669   void * jresult ;
41670   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41671   Dali::Vector2 *result = 0 ;
41672
41673   arg1 = (Dali::PanGesture *)jarg1;
41674   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41675   jresult = (void *)result;
41676   return jresult;
41677 }
41678
41679
41680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41681   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41682   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41683
41684   arg1 = (Dali::PanGesture *)jarg1;
41685   arg2 = (Dali::Vector2 *)jarg2;
41686   if (arg1) (arg1)->screenDisplacement = *arg2;
41687 }
41688
41689
41690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41691   void * jresult ;
41692   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41693   Dali::Vector2 *result = 0 ;
41694
41695   arg1 = (Dali::PanGesture *)jarg1;
41696   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41697   jresult = (void *)result;
41698   return jresult;
41699 }
41700
41701
41702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41703   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41704   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41705
41706   arg1 = (Dali::PanGesture *)jarg1;
41707   arg2 = (Dali::Vector2 *)jarg2;
41708   if (arg1) (arg1)->screenPosition = *arg2;
41709 }
41710
41711
41712 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41713   void * jresult ;
41714   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41715   Dali::Vector2 *result = 0 ;
41716
41717   arg1 = (Dali::PanGesture *)jarg1;
41718   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41719   jresult = (void *)result;
41720   return jresult;
41721 }
41722
41723
41724 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41725   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41726   unsigned int arg2 ;
41727
41728   arg1 = (Dali::PanGesture *)jarg1;
41729   arg2 = (unsigned int)jarg2;
41730   if (arg1) (arg1)->numberOfTouches = arg2;
41731 }
41732
41733
41734 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41735   unsigned int jresult ;
41736   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41737   unsigned int result;
41738
41739   arg1 = (Dali::PanGesture *)jarg1;
41740   result = (unsigned int) ((arg1)->numberOfTouches);
41741   jresult = result;
41742   return jresult;
41743 }
41744
41745
41746 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41747   float jresult ;
41748   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41749   float result;
41750
41751   arg1 = (Dali::PanGesture *)jarg1;
41752   {
41753     try {
41754       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41755     } catch (std::out_of_range& e) {
41756       {
41757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41758       };
41759     } catch (std::exception& e) {
41760       {
41761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41762       };
41763     } catch (Dali::DaliException e) {
41764       {
41765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41766       };
41767     } catch (...) {
41768       {
41769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41770       };
41771     }
41772   }
41773
41774   jresult = result;
41775   return jresult;
41776 }
41777
41778
41779 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41780   float jresult ;
41781   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41782   float result;
41783
41784   arg1 = (Dali::PanGesture *)jarg1;
41785   {
41786     try {
41787       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41788     } catch (std::out_of_range& e) {
41789       {
41790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41791       };
41792     } catch (std::exception& e) {
41793       {
41794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41795       };
41796     } catch (Dali::DaliException e) {
41797       {
41798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41799       };
41800     } catch (...) {
41801       {
41802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41803       };
41804     }
41805   }
41806
41807   jresult = result;
41808   return jresult;
41809 }
41810
41811
41812 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41813   float jresult ;
41814   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41815   float result;
41816
41817   arg1 = (Dali::PanGesture *)jarg1;
41818   {
41819     try {
41820       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41821     } catch (std::out_of_range& e) {
41822       {
41823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41824       };
41825     } catch (std::exception& e) {
41826       {
41827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41828       };
41829     } catch (Dali::DaliException e) {
41830       {
41831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41832       };
41833     } catch (...) {
41834       {
41835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41836       };
41837     }
41838   }
41839
41840   jresult = result;
41841   return jresult;
41842 }
41843
41844
41845 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41846   float jresult ;
41847   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41848   float result;
41849
41850   arg1 = (Dali::PanGesture *)jarg1;
41851   {
41852     try {
41853       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
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 (Dali::DaliException e) {
41863       {
41864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41865       };
41866     } catch (...) {
41867       {
41868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41869       };
41870     }
41871   }
41872
41873   jresult = result;
41874   return jresult;
41875 }
41876
41877
41878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41879   void * jresult ;
41880   Dali::PinchGestureDetector *result = 0 ;
41881
41882   {
41883     try {
41884       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41885     } catch (std::out_of_range& e) {
41886       {
41887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41888       };
41889     } catch (std::exception& e) {
41890       {
41891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41892       };
41893     } catch (Dali::DaliException e) {
41894       {
41895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41896       };
41897     } catch (...) {
41898       {
41899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41900       };
41901     }
41902   }
41903
41904   jresult = (void *)result;
41905   return jresult;
41906 }
41907
41908
41909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41910   void * jresult ;
41911   Dali::PinchGestureDetector result;
41912
41913   {
41914     try {
41915       result = Dali::PinchGestureDetector::New();
41916     } catch (std::out_of_range& e) {
41917       {
41918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41919       };
41920     } catch (std::exception& e) {
41921       {
41922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41923       };
41924     } catch (Dali::DaliException e) {
41925       {
41926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41927       };
41928     } catch (...) {
41929       {
41930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41931       };
41932     }
41933   }
41934
41935   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41936   return jresult;
41937 }
41938
41939
41940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41941   void * jresult ;
41942   Dali::BaseHandle arg1 ;
41943   Dali::BaseHandle *argp1 ;
41944   Dali::PinchGestureDetector result;
41945
41946   argp1 = (Dali::BaseHandle *)jarg1;
41947   if (!argp1) {
41948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41949     return 0;
41950   }
41951   arg1 = *argp1;
41952   {
41953     try {
41954       result = Dali::PinchGestureDetector::DownCast(arg1);
41955     } catch (std::out_of_range& e) {
41956       {
41957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41958       };
41959     } catch (std::exception& e) {
41960       {
41961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41962       };
41963     } catch (Dali::DaliException e) {
41964       {
41965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41966       };
41967     } catch (...) {
41968       {
41969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41970       };
41971     }
41972   }
41973
41974   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41975   return jresult;
41976 }
41977
41978
41979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41980   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41981
41982   arg1 = (Dali::PinchGestureDetector *)jarg1;
41983   {
41984     try {
41985       delete arg1;
41986     } catch (std::out_of_range& e) {
41987       {
41988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41989       };
41990     } catch (std::exception& e) {
41991       {
41992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41993       };
41994     } catch (Dali::DaliException e) {
41995       {
41996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41997       };
41998     } catch (...) {
41999       {
42000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42001       };
42002     }
42003   }
42004
42005 }
42006
42007
42008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
42009   void * jresult ;
42010   Dali::PinchGestureDetector *arg1 = 0 ;
42011   Dali::PinchGestureDetector *result = 0 ;
42012
42013   arg1 = (Dali::PinchGestureDetector *)jarg1;
42014   if (!arg1) {
42015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42016     return 0;
42017   }
42018   {
42019     try {
42020       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
42021     } catch (std::out_of_range& e) {
42022       {
42023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42024       };
42025     } catch (std::exception& e) {
42026       {
42027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42028       };
42029     } catch (Dali::DaliException e) {
42030       {
42031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42032       };
42033     } catch (...) {
42034       {
42035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42036       };
42037     }
42038   }
42039
42040   jresult = (void *)result;
42041   return jresult;
42042 }
42043
42044
42045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
42046   void * jresult ;
42047   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42048   Dali::PinchGestureDetector *arg2 = 0 ;
42049   Dali::PinchGestureDetector *result = 0 ;
42050
42051   arg1 = (Dali::PinchGestureDetector *)jarg1;
42052   arg2 = (Dali::PinchGestureDetector *)jarg2;
42053   if (!arg2) {
42054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
42055     return 0;
42056   }
42057   {
42058     try {
42059       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
42060     } catch (std::out_of_range& e) {
42061       {
42062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42063       };
42064     } catch (std::exception& e) {
42065       {
42066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42067       };
42068     } catch (Dali::DaliException e) {
42069       {
42070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42071       };
42072     } catch (...) {
42073       {
42074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42075       };
42076     }
42077   }
42078
42079   jresult = (void *)result;
42080   return jresult;
42081 }
42082
42083
42084 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
42085   void * jresult ;
42086   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
42087   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
42088
42089   arg1 = (Dali::PinchGestureDetector *)jarg1;
42090   {
42091     try {
42092       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42093     } catch (std::out_of_range& e) {
42094       {
42095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42096       };
42097     } catch (std::exception& e) {
42098       {
42099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42100       };
42101     } catch (Dali::DaliException e) {
42102       {
42103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42104       };
42105     } catch (...) {
42106       {
42107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42108       };
42109     }
42110   }
42111
42112   jresult = (void *)result;
42113   return jresult;
42114 }
42115
42116
42117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
42118   void * jresult ;
42119   Dali::Gesture::State arg1 ;
42120   Dali::PinchGesture *result = 0 ;
42121
42122   arg1 = (Dali::Gesture::State)jarg1;
42123   {
42124     try {
42125       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
42126     } catch (std::out_of_range& e) {
42127       {
42128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42129       };
42130     } catch (std::exception& e) {
42131       {
42132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42133       };
42134     } catch (Dali::DaliException e) {
42135       {
42136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42137       };
42138     } catch (...) {
42139       {
42140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42141       };
42142     }
42143   }
42144
42145   jresult = (void *)result;
42146   return jresult;
42147 }
42148
42149
42150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
42151   void * jresult ;
42152   Dali::PinchGesture *arg1 = 0 ;
42153   Dali::PinchGesture *result = 0 ;
42154
42155   arg1 = (Dali::PinchGesture *)jarg1;
42156   if (!arg1) {
42157     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42158     return 0;
42159   }
42160   {
42161     try {
42162       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
42163     } catch (std::out_of_range& e) {
42164       {
42165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42166       };
42167     } catch (std::exception& e) {
42168       {
42169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42170       };
42171     } catch (Dali::DaliException e) {
42172       {
42173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42174       };
42175     } catch (...) {
42176       {
42177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42178       };
42179     }
42180   }
42181
42182   jresult = (void *)result;
42183   return jresult;
42184 }
42185
42186
42187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
42188   void * jresult ;
42189   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42190   Dali::PinchGesture *arg2 = 0 ;
42191   Dali::PinchGesture *result = 0 ;
42192
42193   arg1 = (Dali::PinchGesture *)jarg1;
42194   arg2 = (Dali::PinchGesture *)jarg2;
42195   if (!arg2) {
42196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
42197     return 0;
42198   }
42199   {
42200     try {
42201       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
42202     } catch (std::out_of_range& e) {
42203       {
42204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42205       };
42206     } catch (std::exception& e) {
42207       {
42208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42209       };
42210     } catch (Dali::DaliException e) {
42211       {
42212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42213       };
42214     } catch (...) {
42215       {
42216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42217       };
42218     }
42219   }
42220
42221   jresult = (void *)result;
42222   return jresult;
42223 }
42224
42225
42226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
42227   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42228
42229   arg1 = (Dali::PinchGesture *)jarg1;
42230   {
42231     try {
42232       delete arg1;
42233     } catch (std::out_of_range& e) {
42234       {
42235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42236       };
42237     } catch (std::exception& e) {
42238       {
42239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42240       };
42241     } catch (Dali::DaliException e) {
42242       {
42243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42244       };
42245     } catch (...) {
42246       {
42247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42248       };
42249     }
42250   }
42251
42252 }
42253
42254
42255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
42256   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42257   float arg2 ;
42258
42259   arg1 = (Dali::PinchGesture *)jarg1;
42260   arg2 = (float)jarg2;
42261   if (arg1) (arg1)->scale = arg2;
42262 }
42263
42264
42265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
42266   float jresult ;
42267   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42268   float result;
42269
42270   arg1 = (Dali::PinchGesture *)jarg1;
42271   result = (float) ((arg1)->scale);
42272   jresult = result;
42273   return jresult;
42274 }
42275
42276
42277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
42278   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42279   float arg2 ;
42280
42281   arg1 = (Dali::PinchGesture *)jarg1;
42282   arg2 = (float)jarg2;
42283   if (arg1) (arg1)->speed = arg2;
42284 }
42285
42286
42287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
42288   float jresult ;
42289   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42290   float result;
42291
42292   arg1 = (Dali::PinchGesture *)jarg1;
42293   result = (float) ((arg1)->speed);
42294   jresult = result;
42295   return jresult;
42296 }
42297
42298
42299 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
42300   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42301   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42302
42303   arg1 = (Dali::PinchGesture *)jarg1;
42304   arg2 = (Dali::Vector2 *)jarg2;
42305   if (arg1) (arg1)->screenCenterPoint = *arg2;
42306 }
42307
42308
42309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
42310   void * jresult ;
42311   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42312   Dali::Vector2 *result = 0 ;
42313
42314   arg1 = (Dali::PinchGesture *)jarg1;
42315   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
42316   jresult = (void *)result;
42317   return jresult;
42318 }
42319
42320
42321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
42322   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42323   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42324
42325   arg1 = (Dali::PinchGesture *)jarg1;
42326   arg2 = (Dali::Vector2 *)jarg2;
42327   if (arg1) (arg1)->localCenterPoint = *arg2;
42328 }
42329
42330
42331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
42332   void * jresult ;
42333   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
42334   Dali::Vector2 *result = 0 ;
42335
42336   arg1 = (Dali::PinchGesture *)jarg1;
42337   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
42338   jresult = (void *)result;
42339   return jresult;
42340 }
42341
42342
42343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
42344   void * jresult ;
42345   Dali::TapGestureDetector *result = 0 ;
42346
42347   {
42348     try {
42349       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
42350     } catch (std::out_of_range& e) {
42351       {
42352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42353       };
42354     } catch (std::exception& e) {
42355       {
42356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42357       };
42358     } catch (Dali::DaliException e) {
42359       {
42360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42361       };
42362     } catch (...) {
42363       {
42364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42365       };
42366     }
42367   }
42368
42369   jresult = (void *)result;
42370   return jresult;
42371 }
42372
42373
42374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
42375   void * jresult ;
42376   Dali::TapGestureDetector result;
42377
42378   {
42379     try {
42380       result = Dali::TapGestureDetector::New();
42381     } catch (std::out_of_range& e) {
42382       {
42383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42384       };
42385     } catch (std::exception& e) {
42386       {
42387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42388       };
42389     } catch (Dali::DaliException e) {
42390       {
42391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42392       };
42393     } catch (...) {
42394       {
42395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42396       };
42397     }
42398   }
42399
42400   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42401   return jresult;
42402 }
42403
42404
42405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
42406   void * jresult ;
42407   unsigned int arg1 ;
42408   Dali::TapGestureDetector result;
42409
42410   arg1 = (unsigned int)jarg1;
42411   {
42412     try {
42413       result = Dali::TapGestureDetector::New(arg1);
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 (Dali::DaliException e) {
42423       {
42424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42425       };
42426     } catch (...) {
42427       {
42428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42429       };
42430     }
42431   }
42432
42433   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42434   return jresult;
42435 }
42436
42437
42438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42439   void * jresult ;
42440   Dali::BaseHandle arg1 ;
42441   Dali::BaseHandle *argp1 ;
42442   Dali::TapGestureDetector result;
42443
42444   argp1 = (Dali::BaseHandle *)jarg1;
42445   if (!argp1) {
42446     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42447     return 0;
42448   }
42449   arg1 = *argp1;
42450   {
42451     try {
42452       result = Dali::TapGestureDetector::DownCast(arg1);
42453     } catch (std::out_of_range& e) {
42454       {
42455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42456       };
42457     } catch (std::exception& e) {
42458       {
42459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42460       };
42461     } catch (Dali::DaliException e) {
42462       {
42463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42464       };
42465     } catch (...) {
42466       {
42467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42468       };
42469     }
42470   }
42471
42472   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42473   return jresult;
42474 }
42475
42476
42477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42478   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42479
42480   arg1 = (Dali::TapGestureDetector *)jarg1;
42481   {
42482     try {
42483       delete arg1;
42484     } catch (std::out_of_range& e) {
42485       {
42486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42487       };
42488     } catch (std::exception& e) {
42489       {
42490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42491       };
42492     } catch (Dali::DaliException e) {
42493       {
42494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42495       };
42496     } catch (...) {
42497       {
42498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42499       };
42500     }
42501   }
42502
42503 }
42504
42505
42506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42507   void * jresult ;
42508   Dali::TapGestureDetector *arg1 = 0 ;
42509   Dali::TapGestureDetector *result = 0 ;
42510
42511   arg1 = (Dali::TapGestureDetector *)jarg1;
42512   if (!arg1) {
42513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42514     return 0;
42515   }
42516   {
42517     try {
42518       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42519     } catch (std::out_of_range& e) {
42520       {
42521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42522       };
42523     } catch (std::exception& e) {
42524       {
42525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42526       };
42527     } catch (Dali::DaliException e) {
42528       {
42529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42530       };
42531     } catch (...) {
42532       {
42533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42534       };
42535     }
42536   }
42537
42538   jresult = (void *)result;
42539   return jresult;
42540 }
42541
42542
42543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42544   void * jresult ;
42545   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42546   Dali::TapGestureDetector *arg2 = 0 ;
42547   Dali::TapGestureDetector *result = 0 ;
42548
42549   arg1 = (Dali::TapGestureDetector *)jarg1;
42550   arg2 = (Dali::TapGestureDetector *)jarg2;
42551   if (!arg2) {
42552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42553     return 0;
42554   }
42555   {
42556     try {
42557       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42558     } catch (std::out_of_range& e) {
42559       {
42560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42561       };
42562     } catch (std::exception& e) {
42563       {
42564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42565       };
42566     } catch (Dali::DaliException e) {
42567       {
42568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42569       };
42570     } catch (...) {
42571       {
42572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42573       };
42574     }
42575   }
42576
42577   jresult = (void *)result;
42578   return jresult;
42579 }
42580
42581
42582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42583   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42584   unsigned int arg2 ;
42585
42586   arg1 = (Dali::TapGestureDetector *)jarg1;
42587   arg2 = (unsigned int)jarg2;
42588   {
42589     try {
42590       (arg1)->SetMinimumTapsRequired(arg2);
42591     } catch (std::out_of_range& e) {
42592       {
42593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42594       };
42595     } catch (std::exception& e) {
42596       {
42597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42598       };
42599     } catch (Dali::DaliException e) {
42600       {
42601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42602       };
42603     } catch (...) {
42604       {
42605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42606       };
42607     }
42608   }
42609
42610 }
42611
42612
42613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42614   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42615   unsigned int arg2 ;
42616
42617   arg1 = (Dali::TapGestureDetector *)jarg1;
42618   arg2 = (unsigned int)jarg2;
42619   {
42620     try {
42621       (arg1)->SetMaximumTapsRequired(arg2);
42622     } catch (std::out_of_range& e) {
42623       {
42624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42625       };
42626     } catch (std::exception& e) {
42627       {
42628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42629       };
42630     } catch (Dali::DaliException e) {
42631       {
42632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42633       };
42634     } catch (...) {
42635       {
42636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42637       };
42638     }
42639   }
42640
42641 }
42642
42643
42644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42645   unsigned int jresult ;
42646   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42647   unsigned int result;
42648
42649   arg1 = (Dali::TapGestureDetector *)jarg1;
42650   {
42651     try {
42652       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42653     } catch (std::out_of_range& e) {
42654       {
42655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42656       };
42657     } catch (std::exception& e) {
42658       {
42659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42660       };
42661     } catch (Dali::DaliException e) {
42662       {
42663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42664       };
42665     } catch (...) {
42666       {
42667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42668       };
42669     }
42670   }
42671
42672   jresult = result;
42673   return jresult;
42674 }
42675
42676
42677 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42678   unsigned int jresult ;
42679   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42680   unsigned int result;
42681
42682   arg1 = (Dali::TapGestureDetector *)jarg1;
42683   {
42684     try {
42685       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42686     } catch (std::out_of_range& e) {
42687       {
42688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42689       };
42690     } catch (std::exception& e) {
42691       {
42692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42693       };
42694     } catch (Dali::DaliException e) {
42695       {
42696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42697       };
42698     } catch (...) {
42699       {
42700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42701       };
42702     }
42703   }
42704
42705   jresult = result;
42706   return jresult;
42707 }
42708
42709
42710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42711   void * jresult ;
42712   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42713   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42714
42715   arg1 = (Dali::TapGestureDetector *)jarg1;
42716   {
42717     try {
42718       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42719     } catch (std::out_of_range& e) {
42720       {
42721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42722       };
42723     } catch (std::exception& e) {
42724       {
42725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42726       };
42727     } catch (Dali::DaliException e) {
42728       {
42729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42730       };
42731     } catch (...) {
42732       {
42733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42734       };
42735     }
42736   }
42737
42738   jresult = (void *)result;
42739   return jresult;
42740 }
42741
42742
42743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42744   void * jresult ;
42745   Dali::TapGesture *result = 0 ;
42746
42747   {
42748     try {
42749       result = (Dali::TapGesture *)new Dali::TapGesture();
42750     } catch (std::out_of_range& e) {
42751       {
42752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42753       };
42754     } catch (std::exception& e) {
42755       {
42756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42757       };
42758     } catch (Dali::DaliException e) {
42759       {
42760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42761       };
42762     } catch (...) {
42763       {
42764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42765       };
42766     }
42767   }
42768
42769   jresult = (void *)result;
42770   return jresult;
42771 }
42772
42773
42774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42775   void * jresult ;
42776   Dali::TapGesture *arg1 = 0 ;
42777   Dali::TapGesture *result = 0 ;
42778
42779   arg1 = (Dali::TapGesture *)jarg1;
42780   if (!arg1) {
42781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42782     return 0;
42783   }
42784   {
42785     try {
42786       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42787     } catch (std::out_of_range& e) {
42788       {
42789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42790       };
42791     } catch (std::exception& e) {
42792       {
42793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42794       };
42795     } catch (Dali::DaliException e) {
42796       {
42797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42798       };
42799     } catch (...) {
42800       {
42801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42802       };
42803     }
42804   }
42805
42806   jresult = (void *)result;
42807   return jresult;
42808 }
42809
42810
42811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42812   void * jresult ;
42813   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42814   Dali::TapGesture *arg2 = 0 ;
42815   Dali::TapGesture *result = 0 ;
42816
42817   arg1 = (Dali::TapGesture *)jarg1;
42818   arg2 = (Dali::TapGesture *)jarg2;
42819   if (!arg2) {
42820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42821     return 0;
42822   }
42823   {
42824     try {
42825       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42826     } catch (std::out_of_range& e) {
42827       {
42828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42829       };
42830     } catch (std::exception& e) {
42831       {
42832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42833       };
42834     } catch (Dali::DaliException e) {
42835       {
42836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42837       };
42838     } catch (...) {
42839       {
42840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42841       };
42842     }
42843   }
42844
42845   jresult = (void *)result;
42846   return jresult;
42847 }
42848
42849
42850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42851   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42852
42853   arg1 = (Dali::TapGesture *)jarg1;
42854   {
42855     try {
42856       delete arg1;
42857     } catch (std::out_of_range& e) {
42858       {
42859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42860       };
42861     } catch (std::exception& e) {
42862       {
42863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42864       };
42865     } catch (Dali::DaliException e) {
42866       {
42867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42868       };
42869     } catch (...) {
42870       {
42871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42872       };
42873     }
42874   }
42875
42876 }
42877
42878
42879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42880   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42881   unsigned int arg2 ;
42882
42883   arg1 = (Dali::TapGesture *)jarg1;
42884   arg2 = (unsigned int)jarg2;
42885   if (arg1) (arg1)->numberOfTaps = arg2;
42886 }
42887
42888
42889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42890   unsigned int jresult ;
42891   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42892   unsigned int result;
42893
42894   arg1 = (Dali::TapGesture *)jarg1;
42895   result = (unsigned int) ((arg1)->numberOfTaps);
42896   jresult = result;
42897   return jresult;
42898 }
42899
42900
42901 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42902   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42903   unsigned int arg2 ;
42904
42905   arg1 = (Dali::TapGesture *)jarg1;
42906   arg2 = (unsigned int)jarg2;
42907   if (arg1) (arg1)->numberOfTouches = arg2;
42908 }
42909
42910
42911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42912   unsigned int jresult ;
42913   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42914   unsigned int result;
42915
42916   arg1 = (Dali::TapGesture *)jarg1;
42917   result = (unsigned int) ((arg1)->numberOfTouches);
42918   jresult = result;
42919   return jresult;
42920 }
42921
42922
42923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42924   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42925   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42926
42927   arg1 = (Dali::TapGesture *)jarg1;
42928   arg2 = (Dali::Vector2 *)jarg2;
42929   if (arg1) (arg1)->screenPoint = *arg2;
42930 }
42931
42932
42933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42934   void * jresult ;
42935   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42936   Dali::Vector2 *result = 0 ;
42937
42938   arg1 = (Dali::TapGesture *)jarg1;
42939   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42940   jresult = (void *)result;
42941   return jresult;
42942 }
42943
42944
42945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42946   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42947   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42948
42949   arg1 = (Dali::TapGesture *)jarg1;
42950   arg2 = (Dali::Vector2 *)jarg2;
42951   if (arg1) (arg1)->localPoint = *arg2;
42952 }
42953
42954
42955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42956   void * jresult ;
42957   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42958   Dali::Vector2 *result = 0 ;
42959
42960   arg1 = (Dali::TapGesture *)jarg1;
42961   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42962   jresult = (void *)result;
42963   return jresult;
42964 }
42965
42966
42967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42968   void * jresult ;
42969   Dali::AlphaFunction *result = 0 ;
42970
42971   {
42972     try {
42973       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
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 (Dali::DaliException e) {
42983       {
42984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42985       };
42986     } catch (...) {
42987       {
42988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42989       };
42990     }
42991   }
42992
42993   jresult = (void *)result;
42994   return jresult;
42995 }
42996
42997
42998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42999   void * jresult ;
43000   Dali::AlphaFunction::BuiltinFunction arg1 ;
43001   Dali::AlphaFunction *result = 0 ;
43002
43003   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
43004   {
43005     try {
43006       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43007     } catch (std::out_of_range& e) {
43008       {
43009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43010       };
43011     } catch (std::exception& e) {
43012       {
43013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43014       };
43015     } catch (Dali::DaliException e) {
43016       {
43017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43018       };
43019     } catch (...) {
43020       {
43021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43022       };
43023     }
43024   }
43025
43026   jresult = (void *)result;
43027   return jresult;
43028 }
43029
43030
43031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
43032   void * jresult ;
43033   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
43034   Dali::AlphaFunction *result = 0 ;
43035
43036   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
43037   {
43038     try {
43039       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
43040     } catch (std::out_of_range& e) {
43041       {
43042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43043       };
43044     } catch (std::exception& e) {
43045       {
43046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43047       };
43048     } catch (Dali::DaliException e) {
43049       {
43050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43051       };
43052     } catch (...) {
43053       {
43054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43055       };
43056     }
43057   }
43058
43059   jresult = (void *)result;
43060   return jresult;
43061 }
43062
43063
43064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
43065   void * jresult ;
43066   Dali::Vector2 *arg1 = 0 ;
43067   Dali::Vector2 *arg2 = 0 ;
43068   Dali::AlphaFunction *result = 0 ;
43069
43070   arg1 = (Dali::Vector2 *)jarg1;
43071   if (!arg1) {
43072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43073     return 0;
43074   }
43075   arg2 = (Dali::Vector2 *)jarg2;
43076   if (!arg2) {
43077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43078     return 0;
43079   }
43080   {
43081     try {
43082       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
43083     } catch (std::out_of_range& e) {
43084       {
43085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43086       };
43087     } catch (std::exception& e) {
43088       {
43089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43090       };
43091     } catch (Dali::DaliException e) {
43092       {
43093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43094       };
43095     } catch (...) {
43096       {
43097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43098       };
43099     }
43100   }
43101
43102   jresult = (void *)result;
43103   return jresult;
43104 }
43105
43106
43107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
43108   void * jresult ;
43109   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43110   Dali::Vector4 result;
43111
43112   arg1 = (Dali::AlphaFunction *)jarg1;
43113   {
43114     try {
43115       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
43116     } catch (std::out_of_range& e) {
43117       {
43118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43119       };
43120     } catch (std::exception& e) {
43121       {
43122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43123       };
43124     } catch (Dali::DaliException e) {
43125       {
43126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43127       };
43128     } catch (...) {
43129       {
43130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43131       };
43132     }
43133   }
43134
43135   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
43136   return jresult;
43137 }
43138
43139
43140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
43141   void * jresult ;
43142   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43143   Dali::AlphaFunctionPrototype result;
43144
43145   arg1 = (Dali::AlphaFunction *)jarg1;
43146   {
43147     try {
43148       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
43149     } catch (std::out_of_range& e) {
43150       {
43151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43152       };
43153     } catch (std::exception& e) {
43154       {
43155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43156       };
43157     } catch (Dali::DaliException e) {
43158       {
43159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43160       };
43161     } catch (...) {
43162       {
43163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43164       };
43165     }
43166   }
43167
43168   jresult = (void *)result;
43169   return jresult;
43170 }
43171
43172
43173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
43174   int jresult ;
43175   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43176   Dali::AlphaFunction::BuiltinFunction result;
43177
43178   arg1 = (Dali::AlphaFunction *)jarg1;
43179   {
43180     try {
43181       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
43182     } catch (std::out_of_range& e) {
43183       {
43184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43185       };
43186     } catch (std::exception& e) {
43187       {
43188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43189       };
43190     } catch (Dali::DaliException e) {
43191       {
43192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43193       };
43194     } catch (...) {
43195       {
43196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43197       };
43198     }
43199   }
43200
43201   jresult = (int)result;
43202   return jresult;
43203 }
43204
43205
43206 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
43207   int jresult ;
43208   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43209   Dali::AlphaFunction::Mode result;
43210
43211   arg1 = (Dali::AlphaFunction *)jarg1;
43212   {
43213     try {
43214       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
43215     } catch (std::out_of_range& e) {
43216       {
43217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43218       };
43219     } catch (std::exception& e) {
43220       {
43221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43222       };
43223     } catch (Dali::DaliException e) {
43224       {
43225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43226       };
43227     } catch (...) {
43228       {
43229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43230       };
43231     }
43232   }
43233
43234   jresult = (int)result;
43235   return jresult;
43236 }
43237
43238
43239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
43240   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
43241
43242   arg1 = (Dali::AlphaFunction *)jarg1;
43243   {
43244     try {
43245       delete arg1;
43246     } catch (std::out_of_range& e) {
43247       {
43248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43249       };
43250     } catch (std::exception& e) {
43251       {
43252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43253       };
43254     } catch (Dali::DaliException e) {
43255       {
43256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43257       };
43258     } catch (...) {
43259       {
43260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43261       };
43262     }
43263   }
43264
43265 }
43266
43267
43268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
43269   void * jresult ;
43270   Dali::KeyFrames result;
43271
43272   {
43273     try {
43274       result = Dali::KeyFrames::New();
43275     } catch (std::out_of_range& e) {
43276       {
43277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43278       };
43279     } catch (std::exception& e) {
43280       {
43281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43282       };
43283     } catch (Dali::DaliException e) {
43284       {
43285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43286       };
43287     } catch (...) {
43288       {
43289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43290       };
43291     }
43292   }
43293
43294   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43295   return jresult;
43296 }
43297
43298
43299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
43300   void * jresult ;
43301   Dali::BaseHandle arg1 ;
43302   Dali::BaseHandle *argp1 ;
43303   Dali::KeyFrames result;
43304
43305   argp1 = (Dali::BaseHandle *)jarg1;
43306   if (!argp1) {
43307     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43308     return 0;
43309   }
43310   arg1 = *argp1;
43311   {
43312     try {
43313       result = Dali::KeyFrames::DownCast(arg1);
43314     } catch (std::out_of_range& e) {
43315       {
43316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43317       };
43318     } catch (std::exception& e) {
43319       {
43320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43321       };
43322     } catch (Dali::DaliException e) {
43323       {
43324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43325       };
43326     } catch (...) {
43327       {
43328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43329       };
43330     }
43331   }
43332
43333   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
43334   return jresult;
43335 }
43336
43337
43338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
43339   void * jresult ;
43340   Dali::KeyFrames *result = 0 ;
43341
43342   {
43343     try {
43344       result = (Dali::KeyFrames *)new Dali::KeyFrames();
43345     } catch (std::out_of_range& e) {
43346       {
43347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43348       };
43349     } catch (std::exception& e) {
43350       {
43351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43352       };
43353     } catch (Dali::DaliException e) {
43354       {
43355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43356       };
43357     } catch (...) {
43358       {
43359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43360       };
43361     }
43362   }
43363
43364   jresult = (void *)result;
43365   return jresult;
43366 }
43367
43368
43369 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
43370   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43371
43372   arg1 = (Dali::KeyFrames *)jarg1;
43373   {
43374     try {
43375       delete arg1;
43376     } catch (std::out_of_range& e) {
43377       {
43378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43379       };
43380     } catch (std::exception& e) {
43381       {
43382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43383       };
43384     } catch (Dali::DaliException e) {
43385       {
43386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43387       };
43388     } catch (...) {
43389       {
43390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43391       };
43392     }
43393   }
43394
43395 }
43396
43397
43398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
43399   void * jresult ;
43400   Dali::KeyFrames *arg1 = 0 ;
43401   Dali::KeyFrames *result = 0 ;
43402
43403   arg1 = (Dali::KeyFrames *)jarg1;
43404   if (!arg1) {
43405     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43406     return 0;
43407   }
43408   {
43409     try {
43410       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43411     } catch (std::out_of_range& e) {
43412       {
43413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43414       };
43415     } catch (std::exception& e) {
43416       {
43417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43418       };
43419     } catch (Dali::DaliException e) {
43420       {
43421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43422       };
43423     } catch (...) {
43424       {
43425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43426       };
43427     }
43428   }
43429
43430   jresult = (void *)result;
43431   return jresult;
43432 }
43433
43434
43435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43436   void * jresult ;
43437   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43438   Dali::KeyFrames *arg2 = 0 ;
43439   Dali::KeyFrames *result = 0 ;
43440
43441   arg1 = (Dali::KeyFrames *)jarg1;
43442   arg2 = (Dali::KeyFrames *)jarg2;
43443   if (!arg2) {
43444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43445     return 0;
43446   }
43447   {
43448     try {
43449       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43450     } catch (std::out_of_range& e) {
43451       {
43452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43453       };
43454     } catch (std::exception& e) {
43455       {
43456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43457       };
43458     } catch (Dali::DaliException e) {
43459       {
43460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43461       };
43462     } catch (...) {
43463       {
43464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43465       };
43466     }
43467   }
43468
43469   jresult = (void *)result;
43470   return jresult;
43471 }
43472
43473
43474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43475   int jresult ;
43476   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43477   Dali::Property::Type result;
43478
43479   arg1 = (Dali::KeyFrames *)jarg1;
43480   {
43481     try {
43482       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43483     } catch (std::out_of_range& e) {
43484       {
43485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43486       };
43487     } catch (std::exception& e) {
43488       {
43489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43490       };
43491     } catch (Dali::DaliException e) {
43492       {
43493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43494       };
43495     } catch (...) {
43496       {
43497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43498       };
43499     }
43500   }
43501
43502   jresult = (int)result;
43503   return jresult;
43504 }
43505
43506
43507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43508   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43509   float arg2 ;
43510   Dali::Property::Value arg3 ;
43511   Dali::Property::Value *argp3 ;
43512
43513   arg1 = (Dali::KeyFrames *)jarg1;
43514   arg2 = (float)jarg2;
43515   argp3 = (Dali::Property::Value *)jarg3;
43516   if (!argp3) {
43517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43518     return ;
43519   }
43520   arg3 = *argp3;
43521   {
43522     try {
43523       (arg1)->Add(arg2,arg3);
43524     } catch (std::out_of_range& e) {
43525       {
43526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43527       };
43528     } catch (std::exception& e) {
43529       {
43530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43531       };
43532     } catch (Dali::DaliException e) {
43533       {
43534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43535       };
43536     } catch (...) {
43537       {
43538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43539       };
43540     }
43541   }
43542
43543 }
43544
43545
43546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43547   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43548   float arg2 ;
43549   Dali::Property::Value arg3 ;
43550   Dali::AlphaFunction arg4 ;
43551   Dali::Property::Value *argp3 ;
43552   Dali::AlphaFunction *argp4 ;
43553
43554   arg1 = (Dali::KeyFrames *)jarg1;
43555   arg2 = (float)jarg2;
43556   argp3 = (Dali::Property::Value *)jarg3;
43557   if (!argp3) {
43558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43559     return ;
43560   }
43561   arg3 = *argp3;
43562   argp4 = (Dali::AlphaFunction *)jarg4;
43563   if (!argp4) {
43564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43565     return ;
43566   }
43567   arg4 = *argp4;
43568   {
43569     try {
43570       (arg1)->Add(arg2,arg3,arg4);
43571     } catch (std::out_of_range& e) {
43572       {
43573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43574       };
43575     } catch (std::exception& e) {
43576       {
43577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43578       };
43579     } catch (Dali::DaliException e) {
43580       {
43581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43582       };
43583     } catch (...) {
43584       {
43585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43586       };
43587     }
43588   }
43589
43590 }
43591
43592
43593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43594   int jresult ;
43595   int result;
43596
43597   result = (int)Dali::Path::Property::POINTS;
43598   jresult = (int)result;
43599   return jresult;
43600 }
43601
43602
43603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43604   int jresult ;
43605   int result;
43606
43607   result = (int)Dali::Path::Property::CONTROL_POINTS;
43608   jresult = (int)result;
43609   return jresult;
43610 }
43611
43612
43613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43614   void * jresult ;
43615   Dali::Path::Property *result = 0 ;
43616
43617   {
43618     try {
43619       result = (Dali::Path::Property *)new Dali::Path::Property();
43620     } catch (std::out_of_range& e) {
43621       {
43622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43623       };
43624     } catch (std::exception& e) {
43625       {
43626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43627       };
43628     } catch (Dali::DaliException e) {
43629       {
43630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43631       };
43632     } catch (...) {
43633       {
43634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43635       };
43636     }
43637   }
43638
43639   jresult = (void *)result;
43640   return jresult;
43641 }
43642
43643
43644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43645   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43646
43647   arg1 = (Dali::Path::Property *)jarg1;
43648   {
43649     try {
43650       delete arg1;
43651     } catch (std::out_of_range& e) {
43652       {
43653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43654       };
43655     } catch (std::exception& e) {
43656       {
43657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43658       };
43659     } catch (Dali::DaliException e) {
43660       {
43661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43662       };
43663     } catch (...) {
43664       {
43665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43666       };
43667     }
43668   }
43669
43670 }
43671
43672
43673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43674   void * jresult ;
43675   Dali::Path result;
43676
43677   {
43678     try {
43679       result = Dali::Path::New();
43680     } catch (std::out_of_range& e) {
43681       {
43682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43683       };
43684     } catch (std::exception& e) {
43685       {
43686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43687       };
43688     } catch (Dali::DaliException e) {
43689       {
43690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43691       };
43692     } catch (...) {
43693       {
43694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43695       };
43696     }
43697   }
43698
43699   jresult = new Dali::Path((const Dali::Path &)result);
43700   return jresult;
43701 }
43702
43703
43704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43705   void * jresult ;
43706   Dali::BaseHandle arg1 ;
43707   Dali::BaseHandle *argp1 ;
43708   Dali::Path result;
43709
43710   argp1 = (Dali::BaseHandle *)jarg1;
43711   if (!argp1) {
43712     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43713     return 0;
43714   }
43715   arg1 = *argp1;
43716   {
43717     try {
43718       result = Dali::Path::DownCast(arg1);
43719     } catch (std::out_of_range& e) {
43720       {
43721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43722       };
43723     } catch (std::exception& e) {
43724       {
43725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43726       };
43727     } catch (Dali::DaliException e) {
43728       {
43729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43730       };
43731     } catch (...) {
43732       {
43733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43734       };
43735     }
43736   }
43737
43738   jresult = new Dali::Path((const Dali::Path &)result);
43739   return jresult;
43740 }
43741
43742
43743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43744   void * jresult ;
43745   Dali::Path *result = 0 ;
43746
43747   {
43748     try {
43749       result = (Dali::Path *)new Dali::Path();
43750     } catch (std::out_of_range& e) {
43751       {
43752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43753       };
43754     } catch (std::exception& e) {
43755       {
43756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43757       };
43758     } catch (Dali::DaliException e) {
43759       {
43760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43761       };
43762     } catch (...) {
43763       {
43764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43765       };
43766     }
43767   }
43768
43769   jresult = (void *)result;
43770   return jresult;
43771 }
43772
43773
43774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43775   Dali::Path *arg1 = (Dali::Path *) 0 ;
43776
43777   arg1 = (Dali::Path *)jarg1;
43778   {
43779     try {
43780       delete arg1;
43781     } catch (std::out_of_range& e) {
43782       {
43783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43784       };
43785     } catch (std::exception& e) {
43786       {
43787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43788       };
43789     } catch (Dali::DaliException e) {
43790       {
43791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43792       };
43793     } catch (...) {
43794       {
43795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43796       };
43797     }
43798   }
43799
43800 }
43801
43802
43803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43804   void * jresult ;
43805   Dali::Path *arg1 = 0 ;
43806   Dali::Path *result = 0 ;
43807
43808   arg1 = (Dali::Path *)jarg1;
43809   if (!arg1) {
43810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43811     return 0;
43812   }
43813   {
43814     try {
43815       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43816     } catch (std::out_of_range& e) {
43817       {
43818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43819       };
43820     } catch (std::exception& e) {
43821       {
43822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43823       };
43824     } catch (Dali::DaliException e) {
43825       {
43826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43827       };
43828     } catch (...) {
43829       {
43830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43831       };
43832     }
43833   }
43834
43835   jresult = (void *)result;
43836   return jresult;
43837 }
43838
43839
43840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43841   void * jresult ;
43842   Dali::Path *arg1 = (Dali::Path *) 0 ;
43843   Dali::Path *arg2 = 0 ;
43844   Dali::Path *result = 0 ;
43845
43846   arg1 = (Dali::Path *)jarg1;
43847   arg2 = (Dali::Path *)jarg2;
43848   if (!arg2) {
43849     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43850     return 0;
43851   }
43852   {
43853     try {
43854       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43855     } catch (std::out_of_range& e) {
43856       {
43857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43858       };
43859     } catch (std::exception& e) {
43860       {
43861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43862       };
43863     } catch (Dali::DaliException e) {
43864       {
43865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43866       };
43867     } catch (...) {
43868       {
43869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43870       };
43871     }
43872   }
43873
43874   jresult = (void *)result;
43875   return jresult;
43876 }
43877
43878
43879 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43880   Dali::Path *arg1 = (Dali::Path *) 0 ;
43881   Dali::Vector3 *arg2 = 0 ;
43882
43883   arg1 = (Dali::Path *)jarg1;
43884   arg2 = (Dali::Vector3 *)jarg2;
43885   if (!arg2) {
43886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43887     return ;
43888   }
43889   {
43890     try {
43891       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43892     } catch (std::out_of_range& e) {
43893       {
43894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43895       };
43896     } catch (std::exception& e) {
43897       {
43898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43899       };
43900     } catch (Dali::DaliException e) {
43901       {
43902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43903       };
43904     } catch (...) {
43905       {
43906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43907       };
43908     }
43909   }
43910
43911 }
43912
43913
43914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43915   Dali::Path *arg1 = (Dali::Path *) 0 ;
43916   Dali::Vector3 *arg2 = 0 ;
43917
43918   arg1 = (Dali::Path *)jarg1;
43919   arg2 = (Dali::Vector3 *)jarg2;
43920   if (!arg2) {
43921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43922     return ;
43923   }
43924   {
43925     try {
43926       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43927     } catch (std::out_of_range& e) {
43928       {
43929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43930       };
43931     } catch (std::exception& e) {
43932       {
43933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43934       };
43935     } catch (Dali::DaliException e) {
43936       {
43937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43938       };
43939     } catch (...) {
43940       {
43941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43942       };
43943     }
43944   }
43945
43946 }
43947
43948
43949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43950   Dali::Path *arg1 = (Dali::Path *) 0 ;
43951   float arg2 ;
43952
43953   arg1 = (Dali::Path *)jarg1;
43954   arg2 = (float)jarg2;
43955   {
43956     try {
43957       (arg1)->GenerateControlPoints(arg2);
43958     } catch (std::out_of_range& e) {
43959       {
43960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43961       };
43962     } catch (std::exception& e) {
43963       {
43964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43965       };
43966     } catch (Dali::DaliException e) {
43967       {
43968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43969       };
43970     } catch (...) {
43971       {
43972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43973       };
43974     }
43975   }
43976
43977 }
43978
43979
43980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43981   Dali::Path *arg1 = (Dali::Path *) 0 ;
43982   float arg2 ;
43983   Dali::Vector3 *arg3 = 0 ;
43984   Dali::Vector3 *arg4 = 0 ;
43985
43986   arg1 = (Dali::Path *)jarg1;
43987   arg2 = (float)jarg2;
43988   arg3 = (Dali::Vector3 *)jarg3;
43989   if (!arg3) {
43990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43991     return ;
43992   }
43993   arg4 = (Dali::Vector3 *)jarg4;
43994   if (!arg4) {
43995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43996     return ;
43997   }
43998   {
43999     try {
44000       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
44001     } catch (std::out_of_range& e) {
44002       {
44003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44004       };
44005     } catch (std::exception& e) {
44006       {
44007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44008       };
44009     } catch (Dali::DaliException e) {
44010       {
44011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44012       };
44013     } catch (...) {
44014       {
44015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44016       };
44017     }
44018   }
44019
44020 }
44021
44022
44023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
44024   void * jresult ;
44025   Dali::Path *arg1 = (Dali::Path *) 0 ;
44026   size_t arg2 ;
44027   Dali::Vector3 *result = 0 ;
44028
44029   arg1 = (Dali::Path *)jarg1;
44030   arg2 = (size_t)jarg2;
44031   {
44032     try {
44033       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
44034     } catch (std::out_of_range& e) {
44035       {
44036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44037       };
44038     } catch (std::exception& e) {
44039       {
44040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44041       };
44042     } catch (Dali::DaliException e) {
44043       {
44044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44045       };
44046     } catch (...) {
44047       {
44048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44049       };
44050     }
44051   }
44052
44053   jresult = (void *)result;
44054   return jresult;
44055 }
44056
44057
44058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
44059   void * jresult ;
44060   Dali::Path *arg1 = (Dali::Path *) 0 ;
44061   size_t arg2 ;
44062   Dali::Vector3 *result = 0 ;
44063
44064   arg1 = (Dali::Path *)jarg1;
44065   arg2 = (size_t)jarg2;
44066   {
44067     try {
44068       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
44069     } catch (std::out_of_range& e) {
44070       {
44071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44072       };
44073     } catch (std::exception& e) {
44074       {
44075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44076       };
44077     } catch (Dali::DaliException e) {
44078       {
44079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44080       };
44081     } catch (...) {
44082       {
44083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44084       };
44085     }
44086   }
44087
44088   jresult = (void *)result;
44089   return jresult;
44090 }
44091
44092
44093 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
44094   unsigned long jresult ;
44095   Dali::Path *arg1 = (Dali::Path *) 0 ;
44096   size_t result;
44097
44098   arg1 = (Dali::Path *)jarg1;
44099   {
44100     try {
44101       result = ((Dali::Path const *)arg1)->GetPointCount();
44102     } catch (std::out_of_range& e) {
44103       {
44104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44105       };
44106     } catch (std::exception& e) {
44107       {
44108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44109       };
44110     } catch (Dali::DaliException e) {
44111       {
44112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44113       };
44114     } catch (...) {
44115       {
44116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44117       };
44118     }
44119   }
44120
44121   jresult = (unsigned long)result;
44122   return jresult;
44123 }
44124
44125
44126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
44127   void * jresult ;
44128   float arg1 ;
44129   Dali::TimePeriod *result = 0 ;
44130
44131   arg1 = (float)jarg1;
44132   {
44133     try {
44134       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
44135     } catch (std::out_of_range& e) {
44136       {
44137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44138       };
44139     } catch (std::exception& e) {
44140       {
44141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44142       };
44143     } catch (Dali::DaliException e) {
44144       {
44145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44146       };
44147     } catch (...) {
44148       {
44149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44150       };
44151     }
44152   }
44153
44154   jresult = (void *)result;
44155   return jresult;
44156 }
44157
44158
44159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
44160   void * jresult ;
44161   float arg1 ;
44162   float arg2 ;
44163   Dali::TimePeriod *result = 0 ;
44164
44165   arg1 = (float)jarg1;
44166   arg2 = (float)jarg2;
44167   {
44168     try {
44169       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
44170     } catch (std::out_of_range& e) {
44171       {
44172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44173       };
44174     } catch (std::exception& e) {
44175       {
44176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44177       };
44178     } catch (Dali::DaliException e) {
44179       {
44180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44181       };
44182     } catch (...) {
44183       {
44184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44185       };
44186     }
44187   }
44188
44189   jresult = (void *)result;
44190   return jresult;
44191 }
44192
44193
44194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
44195   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44196
44197   arg1 = (Dali::TimePeriod *)jarg1;
44198   {
44199     try {
44200       delete arg1;
44201     } catch (std::out_of_range& e) {
44202       {
44203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44204       };
44205     } catch (std::exception& e) {
44206       {
44207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44208       };
44209     } catch (Dali::DaliException e) {
44210       {
44211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44212       };
44213     } catch (...) {
44214       {
44215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44216       };
44217     }
44218   }
44219
44220 }
44221
44222
44223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
44224   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44225   float arg2 ;
44226
44227   arg1 = (Dali::TimePeriod *)jarg1;
44228   arg2 = (float)jarg2;
44229   if (arg1) (arg1)->delaySeconds = arg2;
44230 }
44231
44232
44233 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
44234   float jresult ;
44235   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44236   float result;
44237
44238   arg1 = (Dali::TimePeriod *)jarg1;
44239   result = (float) ((arg1)->delaySeconds);
44240   jresult = result;
44241   return jresult;
44242 }
44243
44244
44245 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
44246   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44247   float arg2 ;
44248
44249   arg1 = (Dali::TimePeriod *)jarg1;
44250   arg2 = (float)jarg2;
44251   if (arg1) (arg1)->durationSeconds = arg2;
44252 }
44253
44254
44255 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
44256   float jresult ;
44257   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
44258   float result;
44259
44260   arg1 = (Dali::TimePeriod *)jarg1;
44261   result = (float) ((arg1)->durationSeconds);
44262   jresult = result;
44263   return jresult;
44264 }
44265
44266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
44267   int jresult ;
44268   int result;
44269
44270   result = (int)Dali::LinearConstrainer::Property::VALUE;
44271   jresult = (int)result;
44272   return jresult;
44273 }
44274
44275
44276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
44277   int jresult ;
44278   int result;
44279
44280   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
44281   jresult = (int)result;
44282   return jresult;
44283 }
44284
44285
44286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
44287   void * jresult ;
44288   Dali::LinearConstrainer::Property *result = 0 ;
44289
44290   {
44291     try {
44292       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
44293     } catch (std::out_of_range& e) {
44294       {
44295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44296       };
44297     } catch (std::exception& e) {
44298       {
44299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44300       };
44301     } catch (Dali::DaliException e) {
44302       {
44303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44304       };
44305     } catch (...) {
44306       {
44307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44308       };
44309     }
44310   }
44311
44312   jresult = (void *)result;
44313   return jresult;
44314 }
44315
44316
44317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
44318   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
44319
44320   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
44321   {
44322     try {
44323       delete arg1;
44324     } catch (std::out_of_range& e) {
44325       {
44326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44327       };
44328     } catch (std::exception& e) {
44329       {
44330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44331       };
44332     } catch (Dali::DaliException e) {
44333       {
44334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44335       };
44336     } catch (...) {
44337       {
44338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44339       };
44340     }
44341   }
44342
44343 }
44344
44345
44346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
44347   void * jresult ;
44348   Dali::LinearConstrainer result;
44349
44350   {
44351     try {
44352       result = Dali::LinearConstrainer::New();
44353     } catch (std::out_of_range& e) {
44354       {
44355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44356       };
44357     } catch (std::exception& e) {
44358       {
44359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44360       };
44361     } catch (Dali::DaliException e) {
44362       {
44363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44364       };
44365     } catch (...) {
44366       {
44367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44368       };
44369     }
44370   }
44371
44372   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44373   return jresult;
44374 }
44375
44376
44377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
44378   void * jresult ;
44379   Dali::BaseHandle arg1 ;
44380   Dali::BaseHandle *argp1 ;
44381   Dali::LinearConstrainer result;
44382
44383   argp1 = (Dali::BaseHandle *)jarg1;
44384   if (!argp1) {
44385     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44386     return 0;
44387   }
44388   arg1 = *argp1;
44389   {
44390     try {
44391       result = Dali::LinearConstrainer::DownCast(arg1);
44392     } catch (std::out_of_range& e) {
44393       {
44394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44395       };
44396     } catch (std::exception& e) {
44397       {
44398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44399       };
44400     } catch (Dali::DaliException e) {
44401       {
44402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44403       };
44404     } catch (...) {
44405       {
44406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44407       };
44408     }
44409   }
44410
44411   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44412   return jresult;
44413 }
44414
44415
44416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44417   void * jresult ;
44418   Dali::LinearConstrainer *result = 0 ;
44419
44420   {
44421     try {
44422       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44423     } catch (std::out_of_range& e) {
44424       {
44425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44426       };
44427     } catch (std::exception& e) {
44428       {
44429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44430       };
44431     } catch (Dali::DaliException e) {
44432       {
44433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44434       };
44435     } catch (...) {
44436       {
44437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44438       };
44439     }
44440   }
44441
44442   jresult = (void *)result;
44443   return jresult;
44444 }
44445
44446
44447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44448   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44449
44450   arg1 = (Dali::LinearConstrainer *)jarg1;
44451   {
44452     try {
44453       delete arg1;
44454     } catch (std::out_of_range& e) {
44455       {
44456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44457       };
44458     } catch (std::exception& e) {
44459       {
44460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44461       };
44462     } catch (Dali::DaliException e) {
44463       {
44464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44465       };
44466     } catch (...) {
44467       {
44468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44469       };
44470     }
44471   }
44472
44473 }
44474
44475
44476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44477   void * jresult ;
44478   Dali::LinearConstrainer *arg1 = 0 ;
44479   Dali::LinearConstrainer *result = 0 ;
44480
44481   arg1 = (Dali::LinearConstrainer *)jarg1;
44482   if (!arg1) {
44483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44484     return 0;
44485   }
44486   {
44487     try {
44488       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44489     } catch (std::out_of_range& e) {
44490       {
44491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44492       };
44493     } catch (std::exception& e) {
44494       {
44495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44496       };
44497     } catch (Dali::DaliException e) {
44498       {
44499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44500       };
44501     } catch (...) {
44502       {
44503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44504       };
44505     }
44506   }
44507
44508   jresult = (void *)result;
44509   return jresult;
44510 }
44511
44512
44513 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44514   void * jresult ;
44515   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44516   Dali::LinearConstrainer *arg2 = 0 ;
44517   Dali::LinearConstrainer *result = 0 ;
44518
44519   arg1 = (Dali::LinearConstrainer *)jarg1;
44520   arg2 = (Dali::LinearConstrainer *)jarg2;
44521   if (!arg2) {
44522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44523     return 0;
44524   }
44525   {
44526     try {
44527       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44528     } catch (std::out_of_range& e) {
44529       {
44530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44531       };
44532     } catch (std::exception& e) {
44533       {
44534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44535       };
44536     } catch (Dali::DaliException e) {
44537       {
44538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44539       };
44540     } catch (...) {
44541       {
44542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44543       };
44544     }
44545   }
44546
44547   jresult = (void *)result;
44548   return jresult;
44549 }
44550
44551
44552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44553   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44554   SwigValueWrapper< Dali::Property > arg2 ;
44555   SwigValueWrapper< Dali::Property > arg3 ;
44556   Dali::Vector2 *arg4 = 0 ;
44557   Dali::Vector2 *arg5 = 0 ;
44558   Dali::Property *argp2 ;
44559   Dali::Property *argp3 ;
44560
44561   arg1 = (Dali::LinearConstrainer *)jarg1;
44562   argp2 = (Dali::Property *)jarg2;
44563   if (!argp2) {
44564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44565     return ;
44566   }
44567   arg2 = *argp2;
44568   argp3 = (Dali::Property *)jarg3;
44569   if (!argp3) {
44570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44571     return ;
44572   }
44573   arg3 = *argp3;
44574   arg4 = (Dali::Vector2 *)jarg4;
44575   if (!arg4) {
44576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44577     return ;
44578   }
44579   arg5 = (Dali::Vector2 *)jarg5;
44580   if (!arg5) {
44581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44582     return ;
44583   }
44584   {
44585     try {
44586       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44587     } catch (std::out_of_range& e) {
44588       {
44589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44590       };
44591     } catch (std::exception& e) {
44592       {
44593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44594       };
44595     } catch (Dali::DaliException e) {
44596       {
44597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44598       };
44599     } catch (...) {
44600       {
44601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44602       };
44603     }
44604   }
44605
44606 }
44607
44608
44609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44610   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44611   SwigValueWrapper< Dali::Property > arg2 ;
44612   SwigValueWrapper< Dali::Property > arg3 ;
44613   Dali::Vector2 *arg4 = 0 ;
44614   Dali::Property *argp2 ;
44615   Dali::Property *argp3 ;
44616
44617   arg1 = (Dali::LinearConstrainer *)jarg1;
44618   argp2 = (Dali::Property *)jarg2;
44619   if (!argp2) {
44620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44621     return ;
44622   }
44623   arg2 = *argp2;
44624   argp3 = (Dali::Property *)jarg3;
44625   if (!argp3) {
44626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44627     return ;
44628   }
44629   arg3 = *argp3;
44630   arg4 = (Dali::Vector2 *)jarg4;
44631   if (!arg4) {
44632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44633     return ;
44634   }
44635   {
44636     try {
44637       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44638     } catch (std::out_of_range& e) {
44639       {
44640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44641       };
44642     } catch (std::exception& e) {
44643       {
44644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44645       };
44646     } catch (Dali::DaliException e) {
44647       {
44648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44649       };
44650     } catch (...) {
44651       {
44652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44653       };
44654     }
44655   }
44656
44657 }
44658
44659
44660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44661   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44662   Dali::Handle *arg2 = 0 ;
44663
44664   arg1 = (Dali::LinearConstrainer *)jarg1;
44665   arg2 = (Dali::Handle *)jarg2;
44666   if (!arg2) {
44667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44668     return ;
44669   }
44670   {
44671     try {
44672       (arg1)->Remove(*arg2);
44673     } catch (std::out_of_range& e) {
44674       {
44675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44676       };
44677     } catch (std::exception& e) {
44678       {
44679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44680       };
44681     } catch (Dali::DaliException e) {
44682       {
44683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44684       };
44685     } catch (...) {
44686       {
44687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44688       };
44689     }
44690   }
44691
44692 }
44693
44694
44695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44696   int jresult ;
44697   int result;
44698
44699   result = (int)Dali::PathConstrainer::Property::FORWARD;
44700   jresult = (int)result;
44701   return jresult;
44702 }
44703
44704
44705 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44706   int jresult ;
44707   int result;
44708
44709   result = (int)Dali::PathConstrainer::Property::POINTS;
44710   jresult = (int)result;
44711   return jresult;
44712 }
44713
44714
44715 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44716   int jresult ;
44717   int result;
44718
44719   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44720   jresult = (int)result;
44721   return jresult;
44722 }
44723
44724
44725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44726   void * jresult ;
44727   Dali::PathConstrainer::Property *result = 0 ;
44728
44729   {
44730     try {
44731       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44732     } catch (std::out_of_range& e) {
44733       {
44734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44735       };
44736     } catch (std::exception& e) {
44737       {
44738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44739       };
44740     } catch (Dali::DaliException e) {
44741       {
44742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44743       };
44744     } catch (...) {
44745       {
44746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44747       };
44748     }
44749   }
44750
44751   jresult = (void *)result;
44752   return jresult;
44753 }
44754
44755
44756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44757   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44758
44759   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44760   {
44761     try {
44762       delete arg1;
44763     } catch (std::out_of_range& e) {
44764       {
44765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44766       };
44767     } catch (std::exception& e) {
44768       {
44769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44770       };
44771     } catch (Dali::DaliException e) {
44772       {
44773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44774       };
44775     } catch (...) {
44776       {
44777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44778       };
44779     }
44780   }
44781
44782 }
44783
44784
44785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44786   void * jresult ;
44787   Dali::PathConstrainer result;
44788
44789   {
44790     try {
44791       result = Dali::PathConstrainer::New();
44792     } catch (std::out_of_range& e) {
44793       {
44794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44795       };
44796     } catch (std::exception& e) {
44797       {
44798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44799       };
44800     } catch (Dali::DaliException e) {
44801       {
44802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44803       };
44804     } catch (...) {
44805       {
44806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44807       };
44808     }
44809   }
44810
44811   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44812   return jresult;
44813 }
44814
44815
44816 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44817   void * jresult ;
44818   Dali::BaseHandle arg1 ;
44819   Dali::BaseHandle *argp1 ;
44820   Dali::PathConstrainer result;
44821
44822   argp1 = (Dali::BaseHandle *)jarg1;
44823   if (!argp1) {
44824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44825     return 0;
44826   }
44827   arg1 = *argp1;
44828   {
44829     try {
44830       result = Dali::PathConstrainer::DownCast(arg1);
44831     } catch (std::out_of_range& e) {
44832       {
44833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44834       };
44835     } catch (std::exception& e) {
44836       {
44837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44838       };
44839     } catch (Dali::DaliException e) {
44840       {
44841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44842       };
44843     } catch (...) {
44844       {
44845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44846       };
44847     }
44848   }
44849
44850   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44851   return jresult;
44852 }
44853
44854
44855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44856   void * jresult ;
44857   Dali::PathConstrainer *result = 0 ;
44858
44859   {
44860     try {
44861       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44862     } catch (std::out_of_range& e) {
44863       {
44864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44865       };
44866     } catch (std::exception& e) {
44867       {
44868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44869       };
44870     } catch (Dali::DaliException e) {
44871       {
44872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44873       };
44874     } catch (...) {
44875       {
44876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44877       };
44878     }
44879   }
44880
44881   jresult = (void *)result;
44882   return jresult;
44883 }
44884
44885
44886 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44887   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44888
44889   arg1 = (Dali::PathConstrainer *)jarg1;
44890   {
44891     try {
44892       delete arg1;
44893     } catch (std::out_of_range& e) {
44894       {
44895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44896       };
44897     } catch (std::exception& e) {
44898       {
44899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44900       };
44901     } catch (Dali::DaliException e) {
44902       {
44903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44904       };
44905     } catch (...) {
44906       {
44907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44908       };
44909     }
44910   }
44911
44912 }
44913
44914
44915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44916   void * jresult ;
44917   Dali::PathConstrainer *arg1 = 0 ;
44918   Dali::PathConstrainer *result = 0 ;
44919
44920   arg1 = (Dali::PathConstrainer *)jarg1;
44921   if (!arg1) {
44922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44923     return 0;
44924   }
44925   {
44926     try {
44927       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44928     } catch (std::out_of_range& e) {
44929       {
44930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44931       };
44932     } catch (std::exception& e) {
44933       {
44934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44935       };
44936     } catch (Dali::DaliException e) {
44937       {
44938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44939       };
44940     } catch (...) {
44941       {
44942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44943       };
44944     }
44945   }
44946
44947   jresult = (void *)result;
44948   return jresult;
44949 }
44950
44951
44952 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44953   void * jresult ;
44954   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44955   Dali::PathConstrainer *arg2 = 0 ;
44956   Dali::PathConstrainer *result = 0 ;
44957
44958   arg1 = (Dali::PathConstrainer *)jarg1;
44959   arg2 = (Dali::PathConstrainer *)jarg2;
44960   if (!arg2) {
44961     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44962     return 0;
44963   }
44964   {
44965     try {
44966       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44967     } catch (std::out_of_range& e) {
44968       {
44969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44970       };
44971     } catch (std::exception& e) {
44972       {
44973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44974       };
44975     } catch (Dali::DaliException e) {
44976       {
44977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44978       };
44979     } catch (...) {
44980       {
44981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44982       };
44983     }
44984   }
44985
44986   jresult = (void *)result;
44987   return jresult;
44988 }
44989
44990
44991 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44992   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44993   SwigValueWrapper< Dali::Property > arg2 ;
44994   SwigValueWrapper< Dali::Property > arg3 ;
44995   Dali::Vector2 *arg4 = 0 ;
44996   Dali::Vector2 *arg5 = 0 ;
44997   Dali::Property *argp2 ;
44998   Dali::Property *argp3 ;
44999
45000   arg1 = (Dali::PathConstrainer *)jarg1;
45001   argp2 = (Dali::Property *)jarg2;
45002   if (!argp2) {
45003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45004     return ;
45005   }
45006   arg2 = *argp2;
45007   argp3 = (Dali::Property *)jarg3;
45008   if (!argp3) {
45009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45010     return ;
45011   }
45012   arg3 = *argp3;
45013   arg4 = (Dali::Vector2 *)jarg4;
45014   if (!arg4) {
45015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45016     return ;
45017   }
45018   arg5 = (Dali::Vector2 *)jarg5;
45019   if (!arg5) {
45020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45021     return ;
45022   }
45023   {
45024     try {
45025       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
45026     } catch (std::out_of_range& e) {
45027       {
45028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45029       };
45030     } catch (std::exception& e) {
45031       {
45032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45033       };
45034     } catch (Dali::DaliException e) {
45035       {
45036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45037       };
45038     } catch (...) {
45039       {
45040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45041       };
45042     }
45043   }
45044
45045 }
45046
45047
45048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
45049   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45050   SwigValueWrapper< Dali::Property > arg2 ;
45051   SwigValueWrapper< Dali::Property > arg3 ;
45052   Dali::Vector2 *arg4 = 0 ;
45053   Dali::Property *argp2 ;
45054   Dali::Property *argp3 ;
45055
45056   arg1 = (Dali::PathConstrainer *)jarg1;
45057   argp2 = (Dali::Property *)jarg2;
45058   if (!argp2) {
45059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45060     return ;
45061   }
45062   arg2 = *argp2;
45063   argp3 = (Dali::Property *)jarg3;
45064   if (!argp3) {
45065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
45066     return ;
45067   }
45068   arg3 = *argp3;
45069   arg4 = (Dali::Vector2 *)jarg4;
45070   if (!arg4) {
45071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
45072     return ;
45073   }
45074   {
45075     try {
45076       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
45077     } catch (std::out_of_range& e) {
45078       {
45079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45080       };
45081     } catch (std::exception& e) {
45082       {
45083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45084       };
45085     } catch (Dali::DaliException e) {
45086       {
45087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45088       };
45089     } catch (...) {
45090       {
45091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45092       };
45093     }
45094   }
45095
45096 }
45097
45098
45099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
45100   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
45101   Dali::Handle *arg2 = 0 ;
45102
45103   arg1 = (Dali::PathConstrainer *)jarg1;
45104   arg2 = (Dali::Handle *)jarg2;
45105   if (!arg2) {
45106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
45107     return ;
45108   }
45109   {
45110     try {
45111       (arg1)->Remove(*arg2);
45112     } catch (std::out_of_range& e) {
45113       {
45114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45115       };
45116     } catch (std::exception& e) {
45117       {
45118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45119       };
45120     } catch (Dali::DaliException e) {
45121       {
45122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45123       };
45124     } catch (...) {
45125       {
45126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45127       };
45128     }
45129   }
45130
45131 }
45132
45133
45134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
45135   int jresult ;
45136   Dali::FittingMode::Type result;
45137
45138   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
45139   jresult = (int)result;
45140   return jresult;
45141 }
45142
45143
45144 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
45145   int jresult ;
45146   Dali::SamplingMode::Type result;
45147
45148   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
45149   jresult = (int)result;
45150   return jresult;
45151 }
45152
45153
45154 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_0() {
45155   void * jresult ;
45156   Dali::NativeImage *result = 0 ;
45157
45158   {
45159     try {
45160       result = (Dali::NativeImage *)new Dali::NativeImage();
45161     } catch (std::out_of_range& e) {
45162       {
45163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45164       };
45165     } catch (std::exception& e) {
45166       {
45167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45168       };
45169     } catch (Dali::DaliException e) {
45170       {
45171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45172       };
45173     } catch (...) {
45174       {
45175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45176       };
45177     }
45178   }
45179
45180   jresult = (void *)result;
45181   return jresult;
45182 }
45183
45184
45185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_NativeImage(void * jarg1) {
45186   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45187
45188   arg1 = (Dali::NativeImage *)jarg1;
45189   {
45190     try {
45191       delete arg1;
45192     } catch (std::out_of_range& e) {
45193       {
45194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45195       };
45196     } catch (std::exception& e) {
45197       {
45198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45199       };
45200     } catch (Dali::DaliException e) {
45201       {
45202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45203       };
45204     } catch (...) {
45205       {
45206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45207       };
45208     }
45209   }
45210
45211 }
45212
45213
45214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_NativeImage__SWIG_1(void * jarg1) {
45215   void * jresult ;
45216   Dali::NativeImage *arg1 = 0 ;
45217   Dali::NativeImage *result = 0 ;
45218
45219   arg1 = (Dali::NativeImage *)jarg1;
45220   if (!arg1) {
45221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45222     return 0;
45223   }
45224   {
45225     try {
45226       result = (Dali::NativeImage *)new Dali::NativeImage((Dali::NativeImage const &)*arg1);
45227     } catch (std::out_of_range& e) {
45228       {
45229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45230       };
45231     } catch (std::exception& e) {
45232       {
45233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45234       };
45235     } catch (Dali::DaliException e) {
45236       {
45237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45238       };
45239     } catch (...) {
45240       {
45241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45242       };
45243     }
45244   }
45245
45246   jresult = (void *)result;
45247   return jresult;
45248 }
45249
45250
45251 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_Assign(void * jarg1, void * jarg2) {
45252   void * jresult ;
45253   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45254   Dali::NativeImage *arg2 = 0 ;
45255   Dali::NativeImage *result = 0 ;
45256
45257   arg1 = (Dali::NativeImage *)jarg1;
45258   arg2 = (Dali::NativeImage *)jarg2;
45259   if (!arg2) {
45260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImage const & type is null", 0);
45261     return 0;
45262   }
45263   {
45264     try {
45265       result = (Dali::NativeImage *) &(arg1)->operator =((Dali::NativeImage const &)*arg2);
45266     } catch (std::out_of_range& e) {
45267       {
45268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45269       };
45270     } catch (std::exception& e) {
45271       {
45272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45273       };
45274     } catch (Dali::DaliException e) {
45275       {
45276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45277       };
45278     } catch (...) {
45279       {
45280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45281       };
45282     }
45283   }
45284
45285   jresult = (void *)result;
45286   return jresult;
45287 }
45288
45289
45290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImage_CreateGlTexture(void * jarg1) {
45291   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45292
45293   arg1 = (Dali::NativeImage *)jarg1;
45294   {
45295     try {
45296       (arg1)->CreateGlTexture();
45297     } catch (std::out_of_range& e) {
45298       {
45299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45300       };
45301     } catch (std::exception& e) {
45302       {
45303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45304       };
45305     } catch (Dali::DaliException e) {
45306       {
45307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45308       };
45309     } catch (...) {
45310       {
45311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45312       };
45313     }
45314   }
45315
45316 }
45317
45318
45319 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_New(void * jarg1) {
45320   void * jresult ;
45321   NativeImageInterface *arg1 = 0 ;
45322   Dali::NativeImage result;
45323
45324   arg1 = (NativeImageInterface *)jarg1;
45325   if (!arg1) {
45326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
45327     return 0;
45328   }
45329   {
45330     try {
45331       result = Dali::NativeImage::New(*arg1);
45332     } catch (std::out_of_range& e) {
45333       {
45334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45335       };
45336     } catch (std::exception& e) {
45337       {
45338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45339       };
45340     } catch (Dali::DaliException e) {
45341       {
45342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45343       };
45344     } catch (...) {
45345       {
45346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45347       };
45348     }
45349   }
45350
45351   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45352   return jresult;
45353 }
45354
45355
45356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NativeImage_DownCast(void * jarg1) {
45357   void * jresult ;
45358   Dali::BaseHandle arg1 ;
45359   Dali::BaseHandle *argp1 ;
45360   Dali::NativeImage result;
45361
45362   argp1 = (Dali::BaseHandle *)jarg1;
45363   if (!argp1) {
45364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45365     return 0;
45366   }
45367   arg1 = *argp1;
45368   {
45369     try {
45370       result = Dali::NativeImage::DownCast(arg1);
45371     } catch (std::out_of_range& e) {
45372       {
45373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45374       };
45375     } catch (std::exception& e) {
45376       {
45377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45378       };
45379     } catch (Dali::DaliException e) {
45380       {
45381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45382       };
45383     } catch (...) {
45384       {
45385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45386       };
45387     }
45388   }
45389
45390   jresult = new Dali::NativeImage((const Dali::NativeImage &)result);
45391   return jresult;
45392 }
45393
45394
45395 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomFragmentPreFix(void * jarg1) {
45396   char * jresult ;
45397   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45398   char *result = 0 ;
45399
45400   arg1 = (Dali::NativeImage *)jarg1;
45401   {
45402     try {
45403       result = (char *)(arg1)->GetCustomFragmentPreFix();
45404     } catch (std::out_of_range& e) {
45405       {
45406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45407       };
45408     } catch (std::exception& e) {
45409       {
45410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45411       };
45412     } catch (Dali::DaliException e) {
45413       {
45414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45415       };
45416     } catch (...) {
45417       {
45418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45419       };
45420     }
45421   }
45422
45423   jresult = SWIG_csharp_string_callback((const char *)result);
45424   return jresult;
45425 }
45426
45427
45428 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_NativeImage_GetCustomSamplerTypename(void * jarg1) {
45429   char * jresult ;
45430   Dali::NativeImage *arg1 = (Dali::NativeImage *) 0 ;
45431   char *result = 0 ;
45432
45433   arg1 = (Dali::NativeImage *)jarg1;
45434   {
45435     try {
45436       result = (char *)(arg1)->GetCustomSamplerTypename();
45437     } catch (std::out_of_range& e) {
45438       {
45439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45440       };
45441     } catch (std::exception& e) {
45442       {
45443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45444       };
45445     } catch (Dali::DaliException e) {
45446       {
45447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45448       };
45449     } catch (...) {
45450       {
45451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45452       };
45453     }
45454   }
45455
45456   jresult = SWIG_csharp_string_callback((const char *)result);
45457   return jresult;
45458 }
45459
45460
45461 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
45462   unsigned int jresult ;
45463   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45464   bool result;
45465
45466   arg1 = (Dali::NativeImageInterface *)jarg1;
45467   {
45468     try {
45469       result = (bool)(arg1)->GlExtensionCreate();
45470     } catch (std::out_of_range& e) {
45471       {
45472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45473       };
45474     } catch (std::exception& e) {
45475       {
45476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45477       };
45478     } catch (Dali::DaliException e) {
45479       {
45480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45481       };
45482     } catch (...) {
45483       {
45484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45485       };
45486     }
45487   }
45488
45489   jresult = result;
45490   return jresult;
45491 }
45492
45493
45494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
45495   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45496
45497   arg1 = (Dali::NativeImageInterface *)jarg1;
45498   {
45499     try {
45500       (arg1)->GlExtensionDestroy();
45501     } catch (std::out_of_range& e) {
45502       {
45503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45504       };
45505     } catch (std::exception& e) {
45506       {
45507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45508       };
45509     } catch (Dali::DaliException e) {
45510       {
45511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45512       };
45513     } catch (...) {
45514       {
45515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45516       };
45517     }
45518   }
45519
45520 }
45521
45522
45523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
45524   unsigned int jresult ;
45525   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45526   unsigned int result;
45527
45528   arg1 = (Dali::NativeImageInterface *)jarg1;
45529   {
45530     try {
45531       result = (unsigned int)(arg1)->TargetTexture();
45532     } catch (std::out_of_range& e) {
45533       {
45534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45535       };
45536     } catch (std::exception& e) {
45537       {
45538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45539       };
45540     } catch (Dali::DaliException e) {
45541       {
45542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45543       };
45544     } catch (...) {
45545       {
45546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45547       };
45548     }
45549   }
45550
45551   jresult = result;
45552   return jresult;
45553 }
45554
45555
45556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
45557   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45558
45559   arg1 = (Dali::NativeImageInterface *)jarg1;
45560   {
45561     try {
45562       (arg1)->PrepareTexture();
45563     } catch (std::out_of_range& e) {
45564       {
45565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45566       };
45567     } catch (std::exception& e) {
45568       {
45569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45570       };
45571     } catch (Dali::DaliException e) {
45572       {
45573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45574       };
45575     } catch (...) {
45576       {
45577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45578       };
45579     }
45580   }
45581
45582 }
45583
45584
45585 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
45586   unsigned int jresult ;
45587   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45588   unsigned int result;
45589
45590   arg1 = (Dali::NativeImageInterface *)jarg1;
45591   {
45592     try {
45593       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
45594     } catch (std::out_of_range& e) {
45595       {
45596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45597       };
45598     } catch (std::exception& e) {
45599       {
45600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45601       };
45602     } catch (Dali::DaliException e) {
45603       {
45604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45605       };
45606     } catch (...) {
45607       {
45608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45609       };
45610     }
45611   }
45612
45613   jresult = result;
45614   return jresult;
45615 }
45616
45617
45618 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
45619   unsigned int jresult ;
45620   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45621   unsigned int result;
45622
45623   arg1 = (Dali::NativeImageInterface *)jarg1;
45624   {
45625     try {
45626       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
45627     } catch (std::out_of_range& e) {
45628       {
45629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45630       };
45631     } catch (std::exception& e) {
45632       {
45633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45634       };
45635     } catch (Dali::DaliException e) {
45636       {
45637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45638       };
45639     } catch (...) {
45640       {
45641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45642       };
45643     }
45644   }
45645
45646   jresult = result;
45647   return jresult;
45648 }
45649
45650
45651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
45652   unsigned int jresult ;
45653   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
45654   bool result;
45655
45656   arg1 = (Dali::NativeImageInterface *)jarg1;
45657   {
45658     try {
45659       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
45660     } catch (std::out_of_range& e) {
45661       {
45662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45663       };
45664     } catch (std::exception& e) {
45665       {
45666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45667       };
45668     } catch (Dali::DaliException e) {
45669       {
45670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45671       };
45672     } catch (...) {
45673       {
45674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45675       };
45676     }
45677   }
45678
45679   jresult = result;
45680   return jresult;
45681 }
45682
45683
45684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_GetImageSize(char * jarg1) {
45685   void * jresult ;
45686   std::string *arg1 = 0 ;
45687   Dali::ImageDimensions result;
45688
45689   if (!jarg1) {
45690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45691     return 0;
45692   }
45693   std::string arg1_str(jarg1);
45694   arg1 = &arg1_str;
45695   {
45696     try {
45697       result = Dali::ResourceImage::GetImageSize((std::string const &)*arg1);
45698     } catch (std::out_of_range& e) {
45699       {
45700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45701       };
45702     } catch (std::exception& e) {
45703       {
45704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45705       };
45706     } catch (Dali::DaliException e) {
45707       {
45708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45709       };
45710     } catch (...) {
45711       {
45712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45713       };
45714     }
45715   }
45716
45717   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
45718
45719   //argout typemap for const std::string&
45720
45721   return jresult;
45722 }
45723
45724
45725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_0() {
45726   void * jresult ;
45727   Dali::ResourceImage *result = 0 ;
45728
45729   {
45730     try {
45731       result = (Dali::ResourceImage *)new Dali::ResourceImage();
45732     } catch (std::out_of_range& e) {
45733       {
45734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45735       };
45736     } catch (std::exception& e) {
45737       {
45738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45739       };
45740     } catch (Dali::DaliException e) {
45741       {
45742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45743       };
45744     } catch (...) {
45745       {
45746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45747       };
45748     }
45749   }
45750
45751   jresult = (void *)result;
45752   return jresult;
45753 }
45754
45755
45756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImage(void * jarg1) {
45757   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45758
45759   arg1 = (Dali::ResourceImage *)jarg1;
45760   {
45761     try {
45762       delete arg1;
45763     } catch (std::out_of_range& e) {
45764       {
45765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45766       };
45767     } catch (std::exception& e) {
45768       {
45769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45770       };
45771     } catch (Dali::DaliException e) {
45772       {
45773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45774       };
45775     } catch (...) {
45776       {
45777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45778       };
45779     }
45780   }
45781
45782 }
45783
45784
45785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImage__SWIG_1(void * jarg1) {
45786   void * jresult ;
45787   Dali::ResourceImage *arg1 = 0 ;
45788   Dali::ResourceImage *result = 0 ;
45789
45790   arg1 = (Dali::ResourceImage *)jarg1;
45791   if (!arg1) {
45792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
45793     return 0;
45794   }
45795   {
45796     try {
45797       result = (Dali::ResourceImage *)new Dali::ResourceImage((Dali::ResourceImage const &)*arg1);
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 (Dali::DaliException e) {
45807       {
45808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45809       };
45810     } catch (...) {
45811       {
45812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45813       };
45814     }
45815   }
45816
45817   jresult = (void *)result;
45818   return jresult;
45819 }
45820
45821
45822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_Assign(void * jarg1, void * jarg2) {
45823   void * jresult ;
45824   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
45825   Dali::ResourceImage *arg2 = 0 ;
45826   Dali::ResourceImage *result = 0 ;
45827
45828   arg1 = (Dali::ResourceImage *)jarg1;
45829   arg2 = (Dali::ResourceImage *)jarg2;
45830   if (!arg2) {
45831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ResourceImage const & type is null", 0);
45832     return 0;
45833   }
45834   {
45835     try {
45836       result = (Dali::ResourceImage *) &(arg1)->operator =((Dali::ResourceImage const &)*arg2);
45837     } catch (std::out_of_range& e) {
45838       {
45839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45840       };
45841     } catch (std::exception& e) {
45842       {
45843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45844       };
45845     } catch (Dali::DaliException e) {
45846       {
45847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45848       };
45849     } catch (...) {
45850       {
45851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45852       };
45853     }
45854   }
45855
45856   jresult = (void *)result;
45857   return jresult;
45858 }
45859
45860
45861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_0(char * jarg1, unsigned int jarg2) {
45862   void * jresult ;
45863   std::string *arg1 = 0 ;
45864   bool arg2 ;
45865   Dali::ResourceImage result;
45866
45867   if (!jarg1) {
45868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45869     return 0;
45870   }
45871   std::string arg1_str(jarg1);
45872   arg1 = &arg1_str;
45873   arg2 = jarg2 ? true : false;
45874   {
45875     try {
45876       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
45877     } catch (std::out_of_range& e) {
45878       {
45879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45880       };
45881     } catch (std::exception& e) {
45882       {
45883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45884       };
45885     } catch (Dali::DaliException e) {
45886       {
45887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45888       };
45889     } catch (...) {
45890       {
45891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45892       };
45893     }
45894   }
45895
45896   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45897
45898   //argout typemap for const std::string&
45899
45900   return jresult;
45901 }
45902
45903
45904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_1(char * jarg1) {
45905   void * jresult ;
45906   std::string *arg1 = 0 ;
45907   Dali::ResourceImage result;
45908
45909   if (!jarg1) {
45910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45911     return 0;
45912   }
45913   std::string arg1_str(jarg1);
45914   arg1 = &arg1_str;
45915   {
45916     try {
45917       result = Dali::ResourceImage::New((std::string const &)*arg1);
45918     } catch (std::out_of_range& e) {
45919       {
45920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45921       };
45922     } catch (std::exception& e) {
45923       {
45924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45925       };
45926     } catch (Dali::DaliException e) {
45927       {
45928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45929       };
45930     } catch (...) {
45931       {
45932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45933       };
45934     }
45935   }
45936
45937   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45938
45939   //argout typemap for const std::string&
45940
45941   return jresult;
45942 }
45943
45944
45945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
45946   void * jresult ;
45947   std::string *arg1 = 0 ;
45948   Dali::ImageDimensions arg2 ;
45949   Dali::FittingMode::Type arg3 ;
45950   Dali::SamplingMode::Type arg4 ;
45951   bool arg5 ;
45952   Dali::ImageDimensions *argp2 ;
45953   Dali::ResourceImage result;
45954
45955   if (!jarg1) {
45956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45957     return 0;
45958   }
45959   std::string arg1_str(jarg1);
45960   arg1 = &arg1_str;
45961   argp2 = (Dali::ImageDimensions *)jarg2;
45962   if (!argp2) {
45963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
45964     return 0;
45965   }
45966   arg2 = *argp2;
45967   arg3 = (Dali::FittingMode::Type)jarg3;
45968   arg4 = (Dali::SamplingMode::Type)jarg4;
45969   arg5 = jarg5 ? true : false;
45970   {
45971     try {
45972       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4,arg5);
45973     } catch (std::out_of_range& e) {
45974       {
45975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45976       };
45977     } catch (std::exception& e) {
45978       {
45979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45980       };
45981     } catch (Dali::DaliException e) {
45982       {
45983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45984       };
45985     } catch (...) {
45986       {
45987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45988       };
45989     }
45990   }
45991
45992   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
45993
45994   //argout typemap for const std::string&
45995
45996   return jresult;
45997 }
45998
45999
46000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_3(char * jarg1, void * jarg2, int jarg3, int jarg4) {
46001   void * jresult ;
46002   std::string *arg1 = 0 ;
46003   Dali::ImageDimensions arg2 ;
46004   Dali::FittingMode::Type arg3 ;
46005   Dali::SamplingMode::Type arg4 ;
46006   Dali::ImageDimensions *argp2 ;
46007   Dali::ResourceImage result;
46008
46009   if (!jarg1) {
46010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46011     return 0;
46012   }
46013   std::string arg1_str(jarg1);
46014   arg1 = &arg1_str;
46015   argp2 = (Dali::ImageDimensions *)jarg2;
46016   if (!argp2) {
46017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46018     return 0;
46019   }
46020   arg2 = *argp2;
46021   arg3 = (Dali::FittingMode::Type)jarg3;
46022   arg4 = (Dali::SamplingMode::Type)jarg4;
46023   {
46024     try {
46025       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3,arg4);
46026     } catch (std::out_of_range& e) {
46027       {
46028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46029       };
46030     } catch (std::exception& e) {
46031       {
46032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46033       };
46034     } catch (Dali::DaliException e) {
46035       {
46036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46037       };
46038     } catch (...) {
46039       {
46040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46041       };
46042     }
46043   }
46044
46045   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46046
46047   //argout typemap for const std::string&
46048
46049   return jresult;
46050 }
46051
46052
46053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_4(char * jarg1, void * jarg2, int jarg3) {
46054   void * jresult ;
46055   std::string *arg1 = 0 ;
46056   Dali::ImageDimensions arg2 ;
46057   Dali::FittingMode::Type arg3 ;
46058   Dali::ImageDimensions *argp2 ;
46059   Dali::ResourceImage result;
46060
46061   if (!jarg1) {
46062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46063     return 0;
46064   }
46065   std::string arg1_str(jarg1);
46066   arg1 = &arg1_str;
46067   argp2 = (Dali::ImageDimensions *)jarg2;
46068   if (!argp2) {
46069     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46070     return 0;
46071   }
46072   arg2 = *argp2;
46073   arg3 = (Dali::FittingMode::Type)jarg3;
46074   {
46075     try {
46076       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2,arg3);
46077     } catch (std::out_of_range& e) {
46078       {
46079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46080       };
46081     } catch (std::exception& e) {
46082       {
46083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46084       };
46085     } catch (Dali::DaliException e) {
46086       {
46087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46088       };
46089     } catch (...) {
46090       {
46091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46092       };
46093     }
46094   }
46095
46096   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46097
46098   //argout typemap for const std::string&
46099
46100   return jresult;
46101 }
46102
46103
46104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_New__SWIG_5(char * jarg1, void * jarg2) {
46105   void * jresult ;
46106   std::string *arg1 = 0 ;
46107   Dali::ImageDimensions arg2 ;
46108   Dali::ImageDimensions *argp2 ;
46109   Dali::ResourceImage result;
46110
46111   if (!jarg1) {
46112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46113     return 0;
46114   }
46115   std::string arg1_str(jarg1);
46116   arg1 = &arg1_str;
46117   argp2 = (Dali::ImageDimensions *)jarg2;
46118   if (!argp2) {
46119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
46120     return 0;
46121   }
46122   arg2 = *argp2;
46123   {
46124     try {
46125       result = Dali::ResourceImage::New((std::string const &)*arg1,arg2);
46126     } catch (std::out_of_range& e) {
46127       {
46128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46129       };
46130     } catch (std::exception& e) {
46131       {
46132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46133       };
46134     } catch (Dali::DaliException e) {
46135       {
46136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46137       };
46138     } catch (...) {
46139       {
46140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46141       };
46142     }
46143   }
46144
46145   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46146
46147   //argout typemap for const std::string&
46148
46149   return jresult;
46150 }
46151
46152
46153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_DownCast(void * jarg1) {
46154   void * jresult ;
46155   Dali::BaseHandle arg1 ;
46156   Dali::BaseHandle *argp1 ;
46157   Dali::ResourceImage result;
46158
46159   argp1 = (Dali::BaseHandle *)jarg1;
46160   if (!argp1) {
46161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46162     return 0;
46163   }
46164   arg1 = *argp1;
46165   {
46166     try {
46167       result = Dali::ResourceImage::DownCast(arg1);
46168     } catch (std::out_of_range& e) {
46169       {
46170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46171       };
46172     } catch (std::exception& e) {
46173       {
46174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46175       };
46176     } catch (Dali::DaliException e) {
46177       {
46178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46179       };
46180     } catch (...) {
46181       {
46182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46183       };
46184     }
46185   }
46186
46187   jresult = new Dali::ResourceImage((const Dali::ResourceImage &)result);
46188   return jresult;
46189 }
46190
46191
46192 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResourceImage_GetLoadingState(void * jarg1) {
46193   int jresult ;
46194   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46195   Dali::LoadingState result;
46196
46197   arg1 = (Dali::ResourceImage *)jarg1;
46198   {
46199     try {
46200       result = (Dali::LoadingState)((Dali::ResourceImage const *)arg1)->GetLoadingState();
46201     } catch (std::out_of_range& e) {
46202       {
46203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46204       };
46205     } catch (std::exception& e) {
46206       {
46207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46208       };
46209     } catch (Dali::DaliException e) {
46210       {
46211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46212       };
46213     } catch (...) {
46214       {
46215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46216       };
46217     }
46218   }
46219
46220   jresult = (int)result;
46221   return jresult;
46222 }
46223
46224
46225 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ResourceImage_GetUrl(void * jarg1) {
46226   char * jresult ;
46227   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46228   std::string result;
46229
46230   arg1 = (Dali::ResourceImage *)jarg1;
46231   {
46232     try {
46233       result = ((Dali::ResourceImage const *)arg1)->GetUrl();
46234     } catch (std::out_of_range& e) {
46235       {
46236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46237       };
46238     } catch (std::exception& e) {
46239       {
46240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46241       };
46242     } catch (Dali::DaliException e) {
46243       {
46244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46245       };
46246     } catch (...) {
46247       {
46248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46249       };
46250     }
46251   }
46252
46253   jresult = SWIG_csharp_string_callback((&result)->c_str());
46254   return jresult;
46255 }
46256
46257
46258 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImage_Reload(void * jarg1) {
46259   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46260
46261   arg1 = (Dali::ResourceImage *)jarg1;
46262   {
46263     try {
46264       (arg1)->Reload();
46265     } catch (std::out_of_range& e) {
46266       {
46267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46268       };
46269     } catch (std::exception& e) {
46270       {
46271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46272       };
46273     } catch (Dali::DaliException e) {
46274       {
46275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46276       };
46277     } catch (...) {
46278       {
46279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46280       };
46281     }
46282   }
46283
46284 }
46285
46286
46287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceImage_LoadingFinishedSignal(void * jarg1) {
46288   void * jresult ;
46289   Dali::ResourceImage *arg1 = (Dali::ResourceImage *) 0 ;
46290   Dali::ResourceImage::ResourceImageSignal *result = 0 ;
46291
46292   arg1 = (Dali::ResourceImage *)jarg1;
46293   {
46294     try {
46295       result = (Dali::ResourceImage::ResourceImageSignal *) &(arg1)->LoadingFinishedSignal();
46296     } catch (std::out_of_range& e) {
46297       {
46298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46299       };
46300     } catch (std::exception& e) {
46301       {
46302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46303       };
46304     } catch (Dali::DaliException e) {
46305       {
46306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46307       };
46308     } catch (...) {
46309       {
46310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46311       };
46312     }
46313   }
46314
46315   jresult = (void *)result;
46316   return jresult;
46317 }
46318
46319
46320 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_0() {
46321   void * jresult ;
46322   Dali::FrameBufferImage *result = 0 ;
46323
46324   {
46325     try {
46326       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage();
46327     } catch (std::out_of_range& e) {
46328       {
46329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46330       };
46331     } catch (std::exception& e) {
46332       {
46333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46334       };
46335     } catch (Dali::DaliException e) {
46336       {
46337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46338       };
46339     } catch (...) {
46340       {
46341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46342       };
46343     }
46344   }
46345
46346   jresult = (void *)result;
46347   return jresult;
46348 }
46349
46350
46351 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_0(unsigned int jarg1, unsigned int jarg2, int jarg3, int jarg4) {
46352   void * jresult ;
46353   unsigned int arg1 ;
46354   unsigned int arg2 ;
46355   Dali::Pixel::Format arg3 ;
46356   Dali::RenderBuffer::Format arg4 ;
46357   Dali::FrameBufferImage result;
46358
46359   arg1 = (unsigned int)jarg1;
46360   arg2 = (unsigned int)jarg2;
46361   arg3 = (Dali::Pixel::Format)jarg3;
46362   arg4 = (Dali::RenderBuffer::Format)jarg4;
46363   {
46364     try {
46365       result = Dali::FrameBufferImage::New(arg1,arg2,arg3,arg4);
46366     } catch (std::out_of_range& e) {
46367       {
46368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46369       };
46370     } catch (std::exception& e) {
46371       {
46372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46373       };
46374     } catch (Dali::DaliException e) {
46375       {
46376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46377       };
46378     } catch (...) {
46379       {
46380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46381       };
46382     }
46383   }
46384
46385   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46386   return jresult;
46387 }
46388
46389
46390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_1(unsigned int jarg1, unsigned int jarg2, int jarg3) {
46391   void * jresult ;
46392   unsigned int arg1 ;
46393   unsigned int arg2 ;
46394   Dali::Pixel::Format arg3 ;
46395   Dali::FrameBufferImage result;
46396
46397   arg1 = (unsigned int)jarg1;
46398   arg2 = (unsigned int)jarg2;
46399   arg3 = (Dali::Pixel::Format)jarg3;
46400   {
46401     try {
46402       result = Dali::FrameBufferImage::New(arg1,arg2,arg3);
46403     } catch (std::out_of_range& e) {
46404       {
46405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46406       };
46407     } catch (std::exception& e) {
46408       {
46409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46410       };
46411     } catch (Dali::DaliException e) {
46412       {
46413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46414       };
46415     } catch (...) {
46416       {
46417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46418       };
46419     }
46420   }
46421
46422   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46423   return jresult;
46424 }
46425
46426
46427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
46428   void * jresult ;
46429   unsigned int arg1 ;
46430   unsigned int arg2 ;
46431   Dali::FrameBufferImage result;
46432
46433   arg1 = (unsigned int)jarg1;
46434   arg2 = (unsigned int)jarg2;
46435   {
46436     try {
46437       result = Dali::FrameBufferImage::New(arg1,arg2);
46438     } catch (std::out_of_range& e) {
46439       {
46440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46441       };
46442     } catch (std::exception& e) {
46443       {
46444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46445       };
46446     } catch (Dali::DaliException e) {
46447       {
46448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46449       };
46450     } catch (...) {
46451       {
46452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46453       };
46454     }
46455   }
46456
46457   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46458   return jresult;
46459 }
46460
46461
46462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_3(unsigned int jarg1) {
46463   void * jresult ;
46464   unsigned int arg1 ;
46465   Dali::FrameBufferImage result;
46466
46467   arg1 = (unsigned int)jarg1;
46468   {
46469     try {
46470       result = Dali::FrameBufferImage::New(arg1);
46471     } catch (std::out_of_range& e) {
46472       {
46473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46474       };
46475     } catch (std::exception& e) {
46476       {
46477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46478       };
46479     } catch (Dali::DaliException e) {
46480       {
46481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46482       };
46483     } catch (...) {
46484       {
46485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46486       };
46487     }
46488   }
46489
46490   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46491   return jresult;
46492 }
46493
46494
46495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_4() {
46496   void * jresult ;
46497   Dali::FrameBufferImage result;
46498
46499   {
46500     try {
46501       result = Dali::FrameBufferImage::New();
46502     } catch (std::out_of_range& e) {
46503       {
46504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46505       };
46506     } catch (std::exception& e) {
46507       {
46508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46509       };
46510     } catch (Dali::DaliException e) {
46511       {
46512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46513       };
46514     } catch (...) {
46515       {
46516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46517       };
46518     }
46519   }
46520
46521   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46522   return jresult;
46523 }
46524
46525
46526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_New__SWIG_5(void * jarg1) {
46527   void * jresult ;
46528   Dali::NativeImageInterface *arg1 = 0 ;
46529   Dali::FrameBufferImage result;
46530
46531   arg1 = (Dali::NativeImageInterface *)jarg1;
46532   if (!arg1) {
46533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::NativeImageInterface & type is null", 0);
46534     return 0;
46535   }
46536   {
46537     try {
46538       result = Dali::FrameBufferImage::New(*arg1);
46539     } catch (std::out_of_range& e) {
46540       {
46541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46542       };
46543     } catch (std::exception& e) {
46544       {
46545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46546       };
46547     } catch (Dali::DaliException e) {
46548       {
46549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46550       };
46551     } catch (...) {
46552       {
46553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46554       };
46555     }
46556   }
46557
46558   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46559   return jresult;
46560 }
46561
46562
46563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_DownCast(void * jarg1) {
46564   void * jresult ;
46565   Dali::BaseHandle arg1 ;
46566   Dali::BaseHandle *argp1 ;
46567   Dali::FrameBufferImage result;
46568
46569   argp1 = (Dali::BaseHandle *)jarg1;
46570   if (!argp1) {
46571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
46572     return 0;
46573   }
46574   arg1 = *argp1;
46575   {
46576     try {
46577       result = Dali::FrameBufferImage::DownCast(arg1);
46578     } catch (std::out_of_range& e) {
46579       {
46580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46581       };
46582     } catch (std::exception& e) {
46583       {
46584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46585       };
46586     } catch (Dali::DaliException e) {
46587       {
46588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46589       };
46590     } catch (...) {
46591       {
46592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46593       };
46594     }
46595   }
46596
46597   jresult = new Dali::FrameBufferImage((const Dali::FrameBufferImage &)result);
46598   return jresult;
46599 }
46600
46601
46602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBufferImage(void * jarg1) {
46603   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
46604
46605   arg1 = (Dali::FrameBufferImage *)jarg1;
46606   {
46607     try {
46608       delete arg1;
46609     } catch (std::out_of_range& e) {
46610       {
46611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46612       };
46613     } catch (std::exception& e) {
46614       {
46615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46616       };
46617     } catch (Dali::DaliException e) {
46618       {
46619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46620       };
46621     } catch (...) {
46622       {
46623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46624       };
46625     }
46626   }
46627
46628 }
46629
46630
46631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBufferImage__SWIG_1(void * jarg1) {
46632   void * jresult ;
46633   Dali::FrameBufferImage *arg1 = 0 ;
46634   Dali::FrameBufferImage *result = 0 ;
46635
46636   arg1 = (Dali::FrameBufferImage *)jarg1;
46637   if (!arg1) {
46638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
46639     return 0;
46640   }
46641   {
46642     try {
46643       result = (Dali::FrameBufferImage *)new Dali::FrameBufferImage((Dali::FrameBufferImage const &)*arg1);
46644     } catch (std::out_of_range& e) {
46645       {
46646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46647       };
46648     } catch (std::exception& e) {
46649       {
46650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46651       };
46652     } catch (Dali::DaliException e) {
46653       {
46654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46655       };
46656     } catch (...) {
46657       {
46658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46659       };
46660     }
46661   }
46662
46663   jresult = (void *)result;
46664   return jresult;
46665 }
46666
46667
46668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBufferImage_Assign(void * jarg1, void * jarg2) {
46669   void * jresult ;
46670   Dali::FrameBufferImage *arg1 = (Dali::FrameBufferImage *) 0 ;
46671   Dali::FrameBufferImage *arg2 = 0 ;
46672   Dali::FrameBufferImage *result = 0 ;
46673
46674   arg1 = (Dali::FrameBufferImage *)jarg1;
46675   arg2 = (Dali::FrameBufferImage *)jarg2;
46676   if (!arg2) {
46677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBufferImage const & type is null", 0);
46678     return 0;
46679   }
46680   {
46681     try {
46682       result = (Dali::FrameBufferImage *) &(arg1)->operator =((Dali::FrameBufferImage const &)*arg2);
46683     } catch (std::out_of_range& e) {
46684       {
46685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46686       };
46687     } catch (std::exception& e) {
46688       {
46689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46690       };
46691     } catch (Dali::DaliException e) {
46692       {
46693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46694       };
46695     } catch (...) {
46696       {
46697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46698       };
46699     }
46700   }
46701
46702   jresult = (void *)result;
46703   return jresult;
46704 }
46705
46706
46707 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
46708   int jresult ;
46709   int result;
46710
46711   result = (int)Dali::CameraActor::Property::TYPE;
46712   jresult = (int)result;
46713   return jresult;
46714 }
46715
46716
46717 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
46718   int jresult ;
46719   int result;
46720
46721   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
46722   jresult = (int)result;
46723   return jresult;
46724 }
46725
46726
46727 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
46728   int jresult ;
46729   int result;
46730
46731   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
46732   jresult = (int)result;
46733   return jresult;
46734 }
46735
46736
46737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
46738   int jresult ;
46739   int result;
46740
46741   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
46742   jresult = (int)result;
46743   return jresult;
46744 }
46745
46746
46747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
46748   int jresult ;
46749   int result;
46750
46751   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
46752   jresult = (int)result;
46753   return jresult;
46754 }
46755
46756
46757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
46758   int jresult ;
46759   int result;
46760
46761   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
46762   jresult = (int)result;
46763   return jresult;
46764 }
46765
46766
46767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
46768   int jresult ;
46769   int result;
46770
46771   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
46772   jresult = (int)result;
46773   return jresult;
46774 }
46775
46776
46777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
46778   int jresult ;
46779   int result;
46780
46781   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
46782   jresult = (int)result;
46783   return jresult;
46784 }
46785
46786
46787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
46788   int jresult ;
46789   int result;
46790
46791   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
46792   jresult = (int)result;
46793   return jresult;
46794 }
46795
46796
46797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
46798   int jresult ;
46799   int result;
46800
46801   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
46802   jresult = (int)result;
46803   return jresult;
46804 }
46805
46806
46807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
46808   int jresult ;
46809   int result;
46810
46811   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
46812   jresult = (int)result;
46813   return jresult;
46814 }
46815
46816
46817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
46818   int jresult ;
46819   int result;
46820
46821   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
46822   jresult = (int)result;
46823   return jresult;
46824 }
46825
46826
46827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
46828   int jresult ;
46829   int result;
46830
46831   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
46832   jresult = (int)result;
46833   return jresult;
46834 }
46835
46836
46837 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
46838   int jresult ;
46839   int result;
46840
46841   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
46842   jresult = (int)result;
46843   return jresult;
46844 }
46845
46846
46847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
46848   void * jresult ;
46849   Dali::CameraActor::Property *result = 0 ;
46850
46851   {
46852     try {
46853       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
46854     } catch (std::out_of_range& e) {
46855       {
46856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46857       };
46858     } catch (std::exception& e) {
46859       {
46860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46861       };
46862     } catch (Dali::DaliException e) {
46863       {
46864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46865       };
46866     } catch (...) {
46867       {
46868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46869       };
46870     }
46871   }
46872
46873   jresult = (void *)result;
46874   return jresult;
46875 }
46876
46877
46878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
46879   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
46880
46881   arg1 = (Dali::CameraActor::Property *)jarg1;
46882   {
46883     try {
46884       delete arg1;
46885     } catch (std::out_of_range& e) {
46886       {
46887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46888       };
46889     } catch (std::exception& e) {
46890       {
46891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46892       };
46893     } catch (Dali::DaliException e) {
46894       {
46895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46896       };
46897     } catch (...) {
46898       {
46899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46900       };
46901     }
46902   }
46903
46904 }
46905
46906
46907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
46908   void * jresult ;
46909   Dali::CameraActor *result = 0 ;
46910
46911   {
46912     try {
46913       result = (Dali::CameraActor *)new Dali::CameraActor();
46914     } catch (std::out_of_range& e) {
46915       {
46916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46917       };
46918     } catch (std::exception& e) {
46919       {
46920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46921       };
46922     } catch (Dali::DaliException e) {
46923       {
46924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46925       };
46926     } catch (...) {
46927       {
46928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46929       };
46930     }
46931   }
46932
46933   jresult = (void *)result;
46934   return jresult;
46935 }
46936
46937
46938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
46939   void * jresult ;
46940   Dali::CameraActor result;
46941
46942   {
46943     try {
46944       result = Dali::CameraActor::New();
46945     } catch (std::out_of_range& e) {
46946       {
46947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46948       };
46949     } catch (std::exception& e) {
46950       {
46951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46952       };
46953     } catch (Dali::DaliException e) {
46954       {
46955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46956       };
46957     } catch (...) {
46958       {
46959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46960       };
46961     }
46962   }
46963
46964   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
46965   return jresult;
46966 }
46967
46968
46969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
46970   void * jresult ;
46971   Dali::Size *arg1 = 0 ;
46972   Dali::CameraActor result;
46973
46974   arg1 = (Dali::Size *)jarg1;
46975   if (!arg1) {
46976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
46977     return 0;
46978   }
46979   {
46980     try {
46981       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
46982     } catch (std::out_of_range& e) {
46983       {
46984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46985       };
46986     } catch (std::exception& e) {
46987       {
46988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46989       };
46990     } catch (Dali::DaliException e) {
46991       {
46992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46993       };
46994     } catch (...) {
46995       {
46996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46997       };
46998     }
46999   }
47000
47001   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
47002   return jresult;
47003 }
47004
47005
47006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
47007   void * jresult ;
47008   Dali::BaseHandle arg1 ;
47009   Dali::BaseHandle *argp1 ;
47010   Dali::CameraActor result;
47011
47012   argp1 = (Dali::BaseHandle *)jarg1;
47013   if (!argp1) {
47014     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
47015     return 0;
47016   }
47017   arg1 = *argp1;
47018   {
47019     try {
47020       result = Dali::CameraActor::DownCast(arg1);
47021     } catch (std::out_of_range& e) {
47022       {
47023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47024       };
47025     } catch (std::exception& e) {
47026       {
47027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47028       };
47029     } catch (Dali::DaliException e) {
47030       {
47031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47032       };
47033     } catch (...) {
47034       {
47035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47036       };
47037     }
47038   }
47039
47040   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
47041   return jresult;
47042 }
47043
47044
47045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
47046   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47047
47048   arg1 = (Dali::CameraActor *)jarg1;
47049   {
47050     try {
47051       delete arg1;
47052     } catch (std::out_of_range& e) {
47053       {
47054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47055       };
47056     } catch (std::exception& e) {
47057       {
47058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47059       };
47060     } catch (Dali::DaliException e) {
47061       {
47062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47063       };
47064     } catch (...) {
47065       {
47066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47067       };
47068     }
47069   }
47070
47071 }
47072
47073
47074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
47075   void * jresult ;
47076   Dali::CameraActor *arg1 = 0 ;
47077   Dali::CameraActor *result = 0 ;
47078
47079   arg1 = (Dali::CameraActor *)jarg1;
47080   if (!arg1) {
47081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
47082     return 0;
47083   }
47084   {
47085     try {
47086       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
47087     } catch (std::out_of_range& e) {
47088       {
47089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47090       };
47091     } catch (std::exception& e) {
47092       {
47093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47094       };
47095     } catch (Dali::DaliException e) {
47096       {
47097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47098       };
47099     } catch (...) {
47100       {
47101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47102       };
47103     }
47104   }
47105
47106   jresult = (void *)result;
47107   return jresult;
47108 }
47109
47110
47111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
47112   void * jresult ;
47113   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47114   Dali::CameraActor *arg2 = 0 ;
47115   Dali::CameraActor *result = 0 ;
47116
47117   arg1 = (Dali::CameraActor *)jarg1;
47118   arg2 = (Dali::CameraActor *)jarg2;
47119   if (!arg2) {
47120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
47121     return 0;
47122   }
47123   {
47124     try {
47125       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
47126     } catch (std::out_of_range& e) {
47127       {
47128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47129       };
47130     } catch (std::exception& e) {
47131       {
47132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47133       };
47134     } catch (Dali::DaliException e) {
47135       {
47136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47137       };
47138     } catch (...) {
47139       {
47140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47141       };
47142     }
47143   }
47144
47145   jresult = (void *)result;
47146   return jresult;
47147 }
47148
47149
47150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
47151   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47152   Dali::Camera::Type arg2 ;
47153
47154   arg1 = (Dali::CameraActor *)jarg1;
47155   arg2 = (Dali::Camera::Type)jarg2;
47156   {
47157     try {
47158       (arg1)->SetType(arg2);
47159     } catch (std::out_of_range& e) {
47160       {
47161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47162       };
47163     } catch (std::exception& e) {
47164       {
47165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47166       };
47167     } catch (Dali::DaliException e) {
47168       {
47169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47170       };
47171     } catch (...) {
47172       {
47173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47174       };
47175     }
47176   }
47177
47178 }
47179
47180
47181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
47182   int jresult ;
47183   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47184   Dali::Camera::Type result;
47185
47186   arg1 = (Dali::CameraActor *)jarg1;
47187   {
47188     try {
47189       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
47190     } catch (std::out_of_range& e) {
47191       {
47192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47193       };
47194     } catch (std::exception& e) {
47195       {
47196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47197       };
47198     } catch (Dali::DaliException e) {
47199       {
47200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47201       };
47202     } catch (...) {
47203       {
47204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47205       };
47206     }
47207   }
47208
47209   jresult = (int)result;
47210   return jresult;
47211 }
47212
47213
47214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
47215   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47216   Dali::Camera::ProjectionMode arg2 ;
47217
47218   arg1 = (Dali::CameraActor *)jarg1;
47219   arg2 = (Dali::Camera::ProjectionMode)jarg2;
47220   {
47221     try {
47222       (arg1)->SetProjectionMode(arg2);
47223     } catch (std::out_of_range& e) {
47224       {
47225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47226       };
47227     } catch (std::exception& e) {
47228       {
47229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47230       };
47231     } catch (Dali::DaliException e) {
47232       {
47233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47234       };
47235     } catch (...) {
47236       {
47237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47238       };
47239     }
47240   }
47241
47242 }
47243
47244
47245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
47246   int jresult ;
47247   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47248   Dali::Camera::ProjectionMode result;
47249
47250   arg1 = (Dali::CameraActor *)jarg1;
47251   {
47252     try {
47253       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
47254     } catch (std::out_of_range& e) {
47255       {
47256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47257       };
47258     } catch (std::exception& e) {
47259       {
47260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47261       };
47262     } catch (Dali::DaliException e) {
47263       {
47264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47265       };
47266     } catch (...) {
47267       {
47268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47269       };
47270     }
47271   }
47272
47273   jresult = (int)result;
47274   return jresult;
47275 }
47276
47277
47278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
47279   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47280   float arg2 ;
47281
47282   arg1 = (Dali::CameraActor *)jarg1;
47283   arg2 = (float)jarg2;
47284   {
47285     try {
47286       (arg1)->SetFieldOfView(arg2);
47287     } catch (std::out_of_range& e) {
47288       {
47289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47290       };
47291     } catch (std::exception& e) {
47292       {
47293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47294       };
47295     } catch (Dali::DaliException e) {
47296       {
47297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47298       };
47299     } catch (...) {
47300       {
47301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47302       };
47303     }
47304   }
47305
47306 }
47307
47308
47309 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
47310   float jresult ;
47311   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47312   float result;
47313
47314   arg1 = (Dali::CameraActor *)jarg1;
47315   {
47316     try {
47317       result = (float)(arg1)->GetFieldOfView();
47318     } catch (std::out_of_range& e) {
47319       {
47320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47321       };
47322     } catch (std::exception& e) {
47323       {
47324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47325       };
47326     } catch (Dali::DaliException e) {
47327       {
47328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47329       };
47330     } catch (...) {
47331       {
47332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47333       };
47334     }
47335   }
47336
47337   jresult = result;
47338   return jresult;
47339 }
47340
47341
47342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
47343   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47344   float arg2 ;
47345
47346   arg1 = (Dali::CameraActor *)jarg1;
47347   arg2 = (float)jarg2;
47348   {
47349     try {
47350       (arg1)->SetAspectRatio(arg2);
47351     } catch (std::out_of_range& e) {
47352       {
47353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47354       };
47355     } catch (std::exception& e) {
47356       {
47357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47358       };
47359     } catch (Dali::DaliException e) {
47360       {
47361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47362       };
47363     } catch (...) {
47364       {
47365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47366       };
47367     }
47368   }
47369
47370 }
47371
47372
47373 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
47374   float jresult ;
47375   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47376   float result;
47377
47378   arg1 = (Dali::CameraActor *)jarg1;
47379   {
47380     try {
47381       result = (float)(arg1)->GetAspectRatio();
47382     } catch (std::out_of_range& e) {
47383       {
47384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47385       };
47386     } catch (std::exception& e) {
47387       {
47388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47389       };
47390     } catch (Dali::DaliException e) {
47391       {
47392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47393       };
47394     } catch (...) {
47395       {
47396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47397       };
47398     }
47399   }
47400
47401   jresult = result;
47402   return jresult;
47403 }
47404
47405
47406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
47407   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47408   float arg2 ;
47409
47410   arg1 = (Dali::CameraActor *)jarg1;
47411   arg2 = (float)jarg2;
47412   {
47413     try {
47414       (arg1)->SetNearClippingPlane(arg2);
47415     } catch (std::out_of_range& e) {
47416       {
47417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47418       };
47419     } catch (std::exception& e) {
47420       {
47421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47422       };
47423     } catch (Dali::DaliException e) {
47424       {
47425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47426       };
47427     } catch (...) {
47428       {
47429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47430       };
47431     }
47432   }
47433
47434 }
47435
47436
47437 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
47438   float jresult ;
47439   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47440   float result;
47441
47442   arg1 = (Dali::CameraActor *)jarg1;
47443   {
47444     try {
47445       result = (float)(arg1)->GetNearClippingPlane();
47446     } catch (std::out_of_range& e) {
47447       {
47448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47449       };
47450     } catch (std::exception& e) {
47451       {
47452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47453       };
47454     } catch (Dali::DaliException e) {
47455       {
47456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47457       };
47458     } catch (...) {
47459       {
47460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47461       };
47462     }
47463   }
47464
47465   jresult = result;
47466   return jresult;
47467 }
47468
47469
47470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
47471   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47472   float arg2 ;
47473
47474   arg1 = (Dali::CameraActor *)jarg1;
47475   arg2 = (float)jarg2;
47476   {
47477     try {
47478       (arg1)->SetFarClippingPlane(arg2);
47479     } catch (std::out_of_range& e) {
47480       {
47481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47482       };
47483     } catch (std::exception& e) {
47484       {
47485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47486       };
47487     } catch (Dali::DaliException e) {
47488       {
47489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47490       };
47491     } catch (...) {
47492       {
47493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47494       };
47495     }
47496   }
47497
47498 }
47499
47500
47501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
47502   float jresult ;
47503   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47504   float result;
47505
47506   arg1 = (Dali::CameraActor *)jarg1;
47507   {
47508     try {
47509       result = (float)(arg1)->GetFarClippingPlane();
47510     } catch (std::out_of_range& e) {
47511       {
47512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47513       };
47514     } catch (std::exception& e) {
47515       {
47516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47517       };
47518     } catch (Dali::DaliException e) {
47519       {
47520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47521       };
47522     } catch (...) {
47523       {
47524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47525       };
47526     }
47527   }
47528
47529   jresult = result;
47530   return jresult;
47531 }
47532
47533
47534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
47535   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47536   Dali::Vector3 *arg2 = 0 ;
47537
47538   arg1 = (Dali::CameraActor *)jarg1;
47539   arg2 = (Dali::Vector3 *)jarg2;
47540   if (!arg2) {
47541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
47542     return ;
47543   }
47544   {
47545     try {
47546       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
47547     } catch (std::out_of_range& e) {
47548       {
47549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47550       };
47551     } catch (std::exception& e) {
47552       {
47553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47554       };
47555     } catch (Dali::DaliException e) {
47556       {
47557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47558       };
47559     } catch (...) {
47560       {
47561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47562       };
47563     }
47564   }
47565
47566 }
47567
47568
47569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
47570   void * jresult ;
47571   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47572   Dali::Vector3 result;
47573
47574   arg1 = (Dali::CameraActor *)jarg1;
47575   {
47576     try {
47577       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
47578     } catch (std::out_of_range& e) {
47579       {
47580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47581       };
47582     } catch (std::exception& e) {
47583       {
47584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47585       };
47586     } catch (Dali::DaliException e) {
47587       {
47588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47589       };
47590     } catch (...) {
47591       {
47592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47593       };
47594     }
47595   }
47596
47597   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
47598   return jresult;
47599 }
47600
47601
47602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
47603   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47604   bool arg2 ;
47605
47606   arg1 = (Dali::CameraActor *)jarg1;
47607   arg2 = jarg2 ? true : false;
47608   {
47609     try {
47610       (arg1)->SetInvertYAxis(arg2);
47611     } catch (std::out_of_range& e) {
47612       {
47613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47614       };
47615     } catch (std::exception& e) {
47616       {
47617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47618       };
47619     } catch (Dali::DaliException e) {
47620       {
47621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47622       };
47623     } catch (...) {
47624       {
47625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47626       };
47627     }
47628   }
47629
47630 }
47631
47632
47633 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
47634   unsigned int jresult ;
47635   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47636   bool result;
47637
47638   arg1 = (Dali::CameraActor *)jarg1;
47639   {
47640     try {
47641       result = (bool)(arg1)->GetInvertYAxis();
47642     } catch (std::out_of_range& e) {
47643       {
47644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47645       };
47646     } catch (std::exception& e) {
47647       {
47648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47649       };
47650     } catch (Dali::DaliException e) {
47651       {
47652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47653       };
47654     } catch (...) {
47655       {
47656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47657       };
47658     }
47659   }
47660
47661   jresult = result;
47662   return jresult;
47663 }
47664
47665
47666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
47667   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47668   Dali::Size *arg2 = 0 ;
47669
47670   arg1 = (Dali::CameraActor *)jarg1;
47671   arg2 = (Dali::Size *)jarg2;
47672   if (!arg2) {
47673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
47674     return ;
47675   }
47676   {
47677     try {
47678       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
47679     } catch (std::out_of_range& e) {
47680       {
47681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47682       };
47683     } catch (std::exception& e) {
47684       {
47685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47686       };
47687     } catch (Dali::DaliException e) {
47688       {
47689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47690       };
47691     } catch (...) {
47692       {
47693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47694       };
47695     }
47696   }
47697
47698 }
47699
47700
47701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
47702   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47703   Dali::Size *arg2 = 0 ;
47704
47705   arg1 = (Dali::CameraActor *)jarg1;
47706   arg2 = (Dali::Size *)jarg2;
47707   if (!arg2) {
47708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
47709     return ;
47710   }
47711   {
47712     try {
47713       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
47714     } catch (std::out_of_range& e) {
47715       {
47716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47717       };
47718     } catch (std::exception& e) {
47719       {
47720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47721       };
47722     } catch (Dali::DaliException e) {
47723       {
47724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47725       };
47726     } catch (...) {
47727       {
47728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47729       };
47730     }
47731   }
47732
47733 }
47734
47735
47736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
47737   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
47738   float arg2 ;
47739   float arg3 ;
47740   float arg4 ;
47741   float arg5 ;
47742   float arg6 ;
47743   float arg7 ;
47744
47745   arg1 = (Dali::CameraActor *)jarg1;
47746   arg2 = (float)jarg2;
47747   arg3 = (float)jarg3;
47748   arg4 = (float)jarg4;
47749   arg5 = (float)jarg5;
47750   arg6 = (float)jarg6;
47751   arg7 = (float)jarg7;
47752   {
47753     try {
47754       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
47755     } catch (std::out_of_range& e) {
47756       {
47757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47758       };
47759     } catch (std::exception& e) {
47760       {
47761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47762       };
47763     } catch (Dali::DaliException e) {
47764       {
47765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47766       };
47767     } catch (...) {
47768       {
47769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47770       };
47771     }
47772   }
47773
47774 }
47775
47776
47777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
47778   void * jresult ;
47779   std::pair< std::string,Dali::Property::Value > *result = 0 ;
47780
47781   {
47782     try {
47783       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
47784     } catch (std::out_of_range& e) {
47785       {
47786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47787       };
47788     } catch (std::exception& e) {
47789       {
47790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47791       };
47792     } catch (Dali::DaliException e) {
47793       {
47794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47795       };
47796     } catch (...) {
47797       {
47798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47799       };
47800     }
47801   }
47802
47803   jresult = (void *)result;
47804   return jresult;
47805 }
47806
47807
47808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
47809   void * jresult ;
47810   std::string arg1 ;
47811   Dali::Property::Value arg2 ;
47812   Dali::Property::Value *argp2 ;
47813   std::pair< std::string,Dali::Property::Value > *result = 0 ;
47814
47815   if (!jarg1) {
47816     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47817     return 0;
47818   }
47819   (&arg1)->assign(jarg1);
47820   argp2 = (Dali::Property::Value *)jarg2;
47821   if (!argp2) {
47822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
47823     return 0;
47824   }
47825   arg2 = *argp2;
47826   {
47827     try {
47828       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
47829     } catch (std::out_of_range& e) {
47830       {
47831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47832       };
47833     } catch (std::exception& e) {
47834       {
47835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47836       };
47837     } catch (Dali::DaliException e) {
47838       {
47839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47840       };
47841     } catch (...) {
47842       {
47843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47844       };
47845     }
47846   }
47847
47848   jresult = (void *)result;
47849   return jresult;
47850 }
47851
47852
47853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
47854   void * jresult ;
47855   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
47856   std::pair< std::string,Dali::Property::Value > *result = 0 ;
47857
47858   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47859   if (!arg1) {
47860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
47861     return 0;
47862   }
47863   {
47864     try {
47865       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);
47866     } catch (std::out_of_range& e) {
47867       {
47868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47869       };
47870     } catch (std::exception& e) {
47871       {
47872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47873       };
47874     } catch (Dali::DaliException e) {
47875       {
47876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47877       };
47878     } catch (...) {
47879       {
47880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47881       };
47882     }
47883   }
47884
47885   jresult = (void *)result;
47886   return jresult;
47887 }
47888
47889
47890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
47891   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
47892   std::string *arg2 = 0 ;
47893
47894   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47895   if (!jarg2) {
47896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
47897     return ;
47898   }
47899   std::string arg2_str(jarg2);
47900   arg2 = &arg2_str;
47901   if (arg1) (arg1)->first = *arg2;
47902
47903   //argout typemap for const std::string&
47904
47905 }
47906
47907
47908 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
47909   char * jresult ;
47910   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
47911   std::string *result = 0 ;
47912
47913   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47914   result = (std::string *) & ((arg1)->first);
47915   jresult = SWIG_csharp_string_callback(result->c_str());
47916   return jresult;
47917 }
47918
47919
47920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
47921   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
47922   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
47923
47924   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47925   arg2 = (Dali::Property::Value *)jarg2;
47926   if (arg1) (arg1)->second = *arg2;
47927 }
47928
47929
47930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
47931   void * jresult ;
47932   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
47933   Dali::Property::Value *result = 0 ;
47934
47935   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47936   result = (Dali::Property::Value *)& ((arg1)->second);
47937   jresult = (void *)result;
47938   return jresult;
47939 }
47940
47941
47942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
47943   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
47944
47945   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
47946   {
47947     try {
47948       delete arg1;
47949     } catch (std::out_of_range& e) {
47950       {
47951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47952       };
47953     } catch (std::exception& e) {
47954       {
47955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47956       };
47957     } catch (Dali::DaliException e) {
47958       {
47959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47960       };
47961     } catch (...) {
47962       {
47963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47964       };
47965     }
47966   }
47967
47968 }
47969
47970
47971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
47972   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47973
47974   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47975   {
47976     try {
47977       (arg1)->clear();
47978     } catch (std::out_of_range& e) {
47979       {
47980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47981       };
47982     } catch (std::exception& e) {
47983       {
47984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47985       };
47986     } catch (Dali::DaliException e) {
47987       {
47988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47989       };
47990     } catch (...) {
47991       {
47992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47993       };
47994     }
47995   }
47996
47997 }
47998
47999
48000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
48001   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48002   Dali::TouchPoint *arg2 = 0 ;
48003
48004   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48005   arg2 = (Dali::TouchPoint *)jarg2;
48006   if (!arg2) {
48007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
48008     return ;
48009   }
48010   {
48011     try {
48012       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
48013     } catch (std::out_of_range& e) {
48014       {
48015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48016       };
48017     } catch (std::exception& e) {
48018       {
48019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48020       };
48021     } catch (Dali::DaliException e) {
48022       {
48023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48024       };
48025     } catch (...) {
48026       {
48027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48028       };
48029     }
48030   }
48031
48032 }
48033
48034
48035 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
48036   unsigned long jresult ;
48037   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48038   std::vector< Dali::TouchPoint >::size_type result;
48039
48040   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48041   {
48042     try {
48043       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
48044     } catch (std::out_of_range& e) {
48045       {
48046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48047       };
48048     } catch (std::exception& e) {
48049       {
48050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48051       };
48052     } catch (Dali::DaliException e) {
48053       {
48054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48055       };
48056     } catch (...) {
48057       {
48058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48059       };
48060     }
48061   }
48062
48063   jresult = (unsigned long)result;
48064   return jresult;
48065 }
48066
48067
48068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
48069   unsigned long jresult ;
48070   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48071   std::vector< Dali::TouchPoint >::size_type result;
48072
48073   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48074   {
48075     try {
48076       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
48077     } catch (std::out_of_range& e) {
48078       {
48079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48080       };
48081     } catch (std::exception& e) {
48082       {
48083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48084       };
48085     } catch (Dali::DaliException e) {
48086       {
48087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48088       };
48089     } catch (...) {
48090       {
48091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48092       };
48093     }
48094   }
48095
48096   jresult = (unsigned long)result;
48097   return jresult;
48098 }
48099
48100
48101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
48102   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48103   std::vector< Dali::TouchPoint >::size_type arg2 ;
48104
48105   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48106   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
48107   {
48108     try {
48109       (arg1)->reserve(arg2);
48110     } catch (std::out_of_range& e) {
48111       {
48112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48113       };
48114     } catch (std::exception& e) {
48115       {
48116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48117       };
48118     } catch (Dali::DaliException e) {
48119       {
48120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48121       };
48122     } catch (...) {
48123       {
48124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48125       };
48126     }
48127   }
48128
48129 }
48130
48131
48132 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
48133   void * jresult ;
48134   std::vector< Dali::TouchPoint > *result = 0 ;
48135
48136   {
48137     try {
48138       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
48139     } catch (std::out_of_range& e) {
48140       {
48141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48142       };
48143     } catch (std::exception& e) {
48144       {
48145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48146       };
48147     } catch (Dali::DaliException e) {
48148       {
48149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48150       };
48151     } catch (...) {
48152       {
48153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48154       };
48155     }
48156   }
48157
48158   jresult = (void *)result;
48159   return jresult;
48160 }
48161
48162
48163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
48164   void * jresult ;
48165   std::vector< Dali::TouchPoint > *arg1 = 0 ;
48166   std::vector< Dali::TouchPoint > *result = 0 ;
48167
48168   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48169   if (!arg1) {
48170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
48171     return 0;
48172   }
48173   {
48174     try {
48175       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
48176     } catch (std::out_of_range& e) {
48177       {
48178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48179       };
48180     } catch (std::exception& e) {
48181       {
48182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48183       };
48184     } catch (Dali::DaliException e) {
48185       {
48186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48187       };
48188     } catch (...) {
48189       {
48190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48191       };
48192     }
48193   }
48194
48195   jresult = (void *)result;
48196   return jresult;
48197 }
48198
48199
48200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
48201   void * jresult ;
48202   int arg1 ;
48203   std::vector< Dali::TouchPoint > *result = 0 ;
48204
48205   arg1 = (int)jarg1;
48206   {
48207     try {
48208       try {
48209         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
48210       }
48211       catch(std::out_of_range &_e) {
48212         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48213         return 0;
48214       }
48215
48216     } catch (std::out_of_range& e) {
48217       {
48218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48219       };
48220     } catch (std::exception& e) {
48221       {
48222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48223       };
48224     } catch (Dali::DaliException e) {
48225       {
48226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48227       };
48228     } catch (...) {
48229       {
48230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48231       };
48232     }
48233   }
48234
48235   jresult = (void *)result;
48236   return jresult;
48237 }
48238
48239
48240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
48241   void * jresult ;
48242   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48243   int arg2 ;
48244   SwigValueWrapper< Dali::TouchPoint > result;
48245
48246   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48247   arg2 = (int)jarg2;
48248   {
48249     try {
48250       try {
48251         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
48252       }
48253       catch(std::out_of_range &_e) {
48254         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48255         return 0;
48256       }
48257
48258     } catch (std::out_of_range& e) {
48259       {
48260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48261       };
48262     } catch (std::exception& e) {
48263       {
48264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48265       };
48266     } catch (Dali::DaliException e) {
48267       {
48268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48269       };
48270     } catch (...) {
48271       {
48272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48273       };
48274     }
48275   }
48276
48277   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
48278   return jresult;
48279 }
48280
48281
48282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
48283   void * jresult ;
48284   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48285   int arg2 ;
48286   Dali::TouchPoint *result = 0 ;
48287
48288   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48289   arg2 = (int)jarg2;
48290   {
48291     try {
48292       try {
48293         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
48294       }
48295       catch(std::out_of_range &_e) {
48296         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48297         return 0;
48298       }
48299
48300     } catch (std::out_of_range& e) {
48301       {
48302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48303       };
48304     } catch (std::exception& e) {
48305       {
48306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48307       };
48308     } catch (Dali::DaliException e) {
48309       {
48310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48311       };
48312     } catch (...) {
48313       {
48314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48315       };
48316     }
48317   }
48318
48319   jresult = (void *)result;
48320   return jresult;
48321 }
48322
48323
48324 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
48325   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48326   int arg2 ;
48327   Dali::TouchPoint *arg3 = 0 ;
48328
48329   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48330   arg2 = (int)jarg2;
48331   arg3 = (Dali::TouchPoint *)jarg3;
48332   if (!arg3) {
48333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
48334     return ;
48335   }
48336   {
48337     try {
48338       try {
48339         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
48340       }
48341       catch(std::out_of_range &_e) {
48342         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48343         return ;
48344       }
48345
48346     } catch (std::out_of_range& e) {
48347       {
48348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48349       };
48350     } catch (std::exception& e) {
48351       {
48352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48353       };
48354     } catch (Dali::DaliException e) {
48355       {
48356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48357       };
48358     } catch (...) {
48359       {
48360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48361       };
48362     }
48363   }
48364
48365 }
48366
48367
48368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
48369   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48370   std::vector< Dali::TouchPoint > *arg2 = 0 ;
48371
48372   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48373   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
48374   if (!arg2) {
48375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
48376     return ;
48377   }
48378   {
48379     try {
48380       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
48381     } catch (std::out_of_range& e) {
48382       {
48383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48384       };
48385     } catch (std::exception& e) {
48386       {
48387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48388       };
48389     } catch (Dali::DaliException e) {
48390       {
48391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48392       };
48393     } catch (...) {
48394       {
48395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48396       };
48397     }
48398   }
48399
48400 }
48401
48402
48403 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
48404   void * jresult ;
48405   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48406   int arg2 ;
48407   int arg3 ;
48408   std::vector< Dali::TouchPoint > *result = 0 ;
48409
48410   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48411   arg2 = (int)jarg2;
48412   arg3 = (int)jarg3;
48413   {
48414     try {
48415       try {
48416         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
48417       }
48418       catch(std::out_of_range &_e) {
48419         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48420         return 0;
48421       }
48422       catch(std::invalid_argument &_e) {
48423         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
48424         return 0;
48425       }
48426
48427     } catch (std::out_of_range& e) {
48428       {
48429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48430       };
48431     } catch (std::exception& e) {
48432       {
48433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48434       };
48435     } catch (Dali::DaliException e) {
48436       {
48437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48438       };
48439     } catch (...) {
48440       {
48441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48442       };
48443     }
48444   }
48445
48446   jresult = (void *)result;
48447   return jresult;
48448 }
48449
48450
48451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
48452   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48453   int arg2 ;
48454   Dali::TouchPoint *arg3 = 0 ;
48455
48456   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48457   arg2 = (int)jarg2;
48458   arg3 = (Dali::TouchPoint *)jarg3;
48459   if (!arg3) {
48460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
48461     return ;
48462   }
48463   {
48464     try {
48465       try {
48466         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
48467       }
48468       catch(std::out_of_range &_e) {
48469         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48470         return ;
48471       }
48472
48473     } catch (std::out_of_range& e) {
48474       {
48475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48476       };
48477     } catch (std::exception& e) {
48478       {
48479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48480       };
48481     } catch (Dali::DaliException e) {
48482       {
48483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48484       };
48485     } catch (...) {
48486       {
48487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48488       };
48489     }
48490   }
48491
48492 }
48493
48494
48495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
48496   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48497   int arg2 ;
48498   std::vector< Dali::TouchPoint > *arg3 = 0 ;
48499
48500   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48501   arg2 = (int)jarg2;
48502   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
48503   if (!arg3) {
48504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
48505     return ;
48506   }
48507   {
48508     try {
48509       try {
48510         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
48511       }
48512       catch(std::out_of_range &_e) {
48513         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48514         return ;
48515       }
48516
48517     } catch (std::out_of_range& e) {
48518       {
48519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48520       };
48521     } catch (std::exception& e) {
48522       {
48523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48524       };
48525     } catch (Dali::DaliException e) {
48526       {
48527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48528       };
48529     } catch (...) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48532       };
48533     }
48534   }
48535
48536 }
48537
48538
48539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
48540   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48541   int arg2 ;
48542
48543   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48544   arg2 = (int)jarg2;
48545   {
48546     try {
48547       try {
48548         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
48549       }
48550       catch(std::out_of_range &_e) {
48551         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48552         return ;
48553       }
48554
48555     } catch (std::out_of_range& e) {
48556       {
48557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48558       };
48559     } catch (std::exception& e) {
48560       {
48561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48562       };
48563     } catch (Dali::DaliException e) {
48564       {
48565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48566       };
48567     } catch (...) {
48568       {
48569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48570       };
48571     }
48572   }
48573
48574 }
48575
48576
48577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
48578   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48579   int arg2 ;
48580   int arg3 ;
48581
48582   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48583   arg2 = (int)jarg2;
48584   arg3 = (int)jarg3;
48585   {
48586     try {
48587       try {
48588         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
48589       }
48590       catch(std::out_of_range &_e) {
48591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48592         return ;
48593       }
48594       catch(std::invalid_argument &_e) {
48595         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
48596         return ;
48597       }
48598
48599     } catch (std::out_of_range& e) {
48600       {
48601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48602       };
48603     } catch (std::exception& e) {
48604       {
48605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48606       };
48607     } catch (Dali::DaliException e) {
48608       {
48609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48610       };
48611     } catch (...) {
48612       {
48613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48614       };
48615     }
48616   }
48617
48618 }
48619
48620
48621 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
48622   void * jresult ;
48623   Dali::TouchPoint *arg1 = 0 ;
48624   int arg2 ;
48625   std::vector< Dali::TouchPoint > *result = 0 ;
48626
48627   arg1 = (Dali::TouchPoint *)jarg1;
48628   if (!arg1) {
48629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
48630     return 0;
48631   }
48632   arg2 = (int)jarg2;
48633   {
48634     try {
48635       try {
48636         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
48637       }
48638       catch(std::out_of_range &_e) {
48639         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48640         return 0;
48641       }
48642
48643     } catch (std::out_of_range& e) {
48644       {
48645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48646       };
48647     } catch (std::exception& e) {
48648       {
48649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48650       };
48651     } catch (Dali::DaliException e) {
48652       {
48653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48654       };
48655     } catch (...) {
48656       {
48657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48658       };
48659     }
48660   }
48661
48662   jresult = (void *)result;
48663   return jresult;
48664 }
48665
48666
48667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
48668   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48669
48670   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48671   {
48672     try {
48673       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
48674     } catch (std::out_of_range& e) {
48675       {
48676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48677       };
48678     } catch (std::exception& e) {
48679       {
48680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48681       };
48682     } catch (Dali::DaliException e) {
48683       {
48684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48685       };
48686     } catch (...) {
48687       {
48688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48689       };
48690     }
48691   }
48692
48693 }
48694
48695
48696 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
48697   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48698   int arg2 ;
48699   int arg3 ;
48700
48701   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48702   arg2 = (int)jarg2;
48703   arg3 = (int)jarg3;
48704   {
48705     try {
48706       try {
48707         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
48708       }
48709       catch(std::out_of_range &_e) {
48710         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48711         return ;
48712       }
48713       catch(std::invalid_argument &_e) {
48714         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
48715         return ;
48716       }
48717
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 (Dali::DaliException e) {
48727       {
48728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48729       };
48730     } catch (...) {
48731       {
48732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48733       };
48734     }
48735   }
48736
48737 }
48738
48739
48740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
48741   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48742   int arg2 ;
48743   std::vector< Dali::TouchPoint > *arg3 = 0 ;
48744
48745   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48746   arg2 = (int)jarg2;
48747   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
48748   if (!arg3) {
48749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
48750     return ;
48751   }
48752   {
48753     try {
48754       try {
48755         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
48756       }
48757       catch(std::out_of_range &_e) {
48758         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
48759         return ;
48760       }
48761
48762     } catch (std::out_of_range& e) {
48763       {
48764         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48765       };
48766     } catch (std::exception& e) {
48767       {
48768         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48769       };
48770     } catch (Dali::DaliException e) {
48771       {
48772         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48773       };
48774     } catch (...) {
48775       {
48776         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48777       };
48778     }
48779   }
48780
48781 }
48782
48783
48784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
48785   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
48786
48787   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
48788   {
48789     try {
48790       delete arg1;
48791     } catch (std::out_of_range& e) {
48792       {
48793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48794       };
48795     } catch (std::exception& e) {
48796       {
48797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48798       };
48799     } catch (Dali::DaliException e) {
48800       {
48801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48802       };
48803     } catch (...) {
48804       {
48805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48806       };
48807     }
48808   }
48809
48810 }
48811
48812
48813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
48814   void * jresult ;
48815   Dali::Rect< int > *result = 0 ;
48816
48817   {
48818     try {
48819       result = (Dali::Rect< int > *)new Dali::Rect< int >();
48820     } catch (std::out_of_range& e) {
48821       {
48822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48823       };
48824     } catch (std::exception& e) {
48825       {
48826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48827       };
48828     } catch (Dali::DaliException e) {
48829       {
48830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48831       };
48832     } catch (...) {
48833       {
48834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48835       };
48836     }
48837   }
48838
48839   jresult = (void *)result;
48840   return jresult;
48841 }
48842
48843
48844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
48845   void * jresult ;
48846   int arg1 ;
48847   int arg2 ;
48848   int arg3 ;
48849   int arg4 ;
48850   Dali::Rect< int > *result = 0 ;
48851
48852   arg1 = (int)jarg1;
48853   arg2 = (int)jarg2;
48854   arg3 = (int)jarg3;
48855   arg4 = (int)jarg4;
48856   {
48857     try {
48858       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
48859     } catch (std::out_of_range& e) {
48860       {
48861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48862       };
48863     } catch (std::exception& e) {
48864       {
48865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48866       };
48867     } catch (Dali::DaliException e) {
48868       {
48869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48870       };
48871     } catch (...) {
48872       {
48873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48874       };
48875     }
48876   }
48877
48878   jresult = (void *)result;
48879   return jresult;
48880 }
48881
48882
48883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
48884   void * jresult ;
48885   Dali::Rect< int > *arg1 = 0 ;
48886   Dali::Rect< int > *result = 0 ;
48887
48888   arg1 = (Dali::Rect< int > *)jarg1;
48889   if (!arg1) {
48890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
48891     return 0;
48892   }
48893   {
48894     try {
48895       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
48896     } catch (std::out_of_range& e) {
48897       {
48898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48899       };
48900     } catch (std::exception& e) {
48901       {
48902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48903       };
48904     } catch (Dali::DaliException e) {
48905       {
48906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48907       };
48908     } catch (...) {
48909       {
48910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48911       };
48912     }
48913   }
48914
48915   jresult = (void *)result;
48916   return jresult;
48917 }
48918
48919
48920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
48921   void * jresult ;
48922   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48923   Dali::Rect< int > *arg2 = 0 ;
48924   Dali::Rect< int > *result = 0 ;
48925
48926   arg1 = (Dali::Rect< int > *)jarg1;
48927   arg2 = (Dali::Rect< int > *)jarg2;
48928   if (!arg2) {
48929     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
48930     return 0;
48931   }
48932   {
48933     try {
48934       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
48935     } catch (std::out_of_range& e) {
48936       {
48937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48938       };
48939     } catch (std::exception& e) {
48940       {
48941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48942       };
48943     } catch (Dali::DaliException e) {
48944       {
48945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48946       };
48947     } catch (...) {
48948       {
48949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48950       };
48951     }
48952   }
48953
48954   jresult = (void *)result;
48955   return jresult;
48956 }
48957
48958
48959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
48960   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48961   int arg2 ;
48962   int arg3 ;
48963   int arg4 ;
48964   int arg5 ;
48965
48966   arg1 = (Dali::Rect< int > *)jarg1;
48967   arg2 = (int)jarg2;
48968   arg3 = (int)jarg3;
48969   arg4 = (int)jarg4;
48970   arg5 = (int)jarg5;
48971   {
48972     try {
48973       (arg1)->Set(arg2,arg3,arg4,arg5);
48974     } catch (std::out_of_range& e) {
48975       {
48976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48977       };
48978     } catch (std::exception& e) {
48979       {
48980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48981       };
48982     } catch (Dali::DaliException e) {
48983       {
48984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48985       };
48986     } catch (...) {
48987       {
48988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48989       };
48990     }
48991   }
48992
48993 }
48994
48995
48996 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
48997   unsigned int jresult ;
48998   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
48999   bool result;
49000
49001   arg1 = (Dali::Rect< int > *)jarg1;
49002   {
49003     try {
49004       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
49005     } catch (std::out_of_range& e) {
49006       {
49007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49008       };
49009     } catch (std::exception& e) {
49010       {
49011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49012       };
49013     } catch (Dali::DaliException e) {
49014       {
49015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49016       };
49017     } catch (...) {
49018       {
49019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49020       };
49021     }
49022   }
49023
49024   jresult = result;
49025   return jresult;
49026 }
49027
49028
49029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
49030   int jresult ;
49031   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49032   int result;
49033
49034   arg1 = (Dali::Rect< int > *)jarg1;
49035   {
49036     try {
49037       result = (int)((Dali::Rect< int > const *)arg1)->Left();
49038     } catch (std::out_of_range& e) {
49039       {
49040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49041       };
49042     } catch (std::exception& e) {
49043       {
49044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49045       };
49046     } catch (Dali::DaliException e) {
49047       {
49048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49049       };
49050     } catch (...) {
49051       {
49052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49053       };
49054     }
49055   }
49056
49057   jresult = result;
49058   return jresult;
49059 }
49060
49061
49062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
49063   int jresult ;
49064   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49065   int result;
49066
49067   arg1 = (Dali::Rect< int > *)jarg1;
49068   {
49069     try {
49070       result = (int)((Dali::Rect< int > const *)arg1)->Right();
49071     } catch (std::out_of_range& e) {
49072       {
49073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49074       };
49075     } catch (std::exception& e) {
49076       {
49077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49078       };
49079     } catch (Dali::DaliException e) {
49080       {
49081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49082       };
49083     } catch (...) {
49084       {
49085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49086       };
49087     }
49088   }
49089
49090   jresult = result;
49091   return jresult;
49092 }
49093
49094
49095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
49096   int jresult ;
49097   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49098   int result;
49099
49100   arg1 = (Dali::Rect< int > *)jarg1;
49101   {
49102     try {
49103       result = (int)((Dali::Rect< int > const *)arg1)->Top();
49104     } catch (std::out_of_range& e) {
49105       {
49106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49107       };
49108     } catch (std::exception& e) {
49109       {
49110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49111       };
49112     } catch (Dali::DaliException e) {
49113       {
49114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49115       };
49116     } catch (...) {
49117       {
49118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49119       };
49120     }
49121   }
49122
49123   jresult = result;
49124   return jresult;
49125 }
49126
49127
49128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
49129   int jresult ;
49130   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49131   int result;
49132
49133   arg1 = (Dali::Rect< int > *)jarg1;
49134   {
49135     try {
49136       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
49137     } catch (std::out_of_range& e) {
49138       {
49139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49140       };
49141     } catch (std::exception& e) {
49142       {
49143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49144       };
49145     } catch (Dali::DaliException e) {
49146       {
49147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49148       };
49149     } catch (...) {
49150       {
49151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49152       };
49153     }
49154   }
49155
49156   jresult = result;
49157   return jresult;
49158 }
49159
49160
49161 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
49162   int jresult ;
49163   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49164   int result;
49165
49166   arg1 = (Dali::Rect< int > *)jarg1;
49167   {
49168     try {
49169       result = (int)((Dali::Rect< int > const *)arg1)->Area();
49170     } catch (std::out_of_range& e) {
49171       {
49172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49173       };
49174     } catch (std::exception& e) {
49175       {
49176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49177       };
49178     } catch (Dali::DaliException e) {
49179       {
49180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49181       };
49182     } catch (...) {
49183       {
49184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49185       };
49186     }
49187   }
49188
49189   jresult = result;
49190   return jresult;
49191 }
49192
49193
49194 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
49195   unsigned int jresult ;
49196   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49197   Dali::Rect< int > *arg2 = 0 ;
49198   bool result;
49199
49200   arg1 = (Dali::Rect< int > *)jarg1;
49201   arg2 = (Dali::Rect< int > *)jarg2;
49202   if (!arg2) {
49203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
49204     return 0;
49205   }
49206   {
49207     try {
49208       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
49209     } catch (std::out_of_range& e) {
49210       {
49211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49212       };
49213     } catch (std::exception& e) {
49214       {
49215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49216       };
49217     } catch (Dali::DaliException e) {
49218       {
49219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49220       };
49221     } catch (...) {
49222       {
49223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49224       };
49225     }
49226   }
49227
49228   jresult = result;
49229   return jresult;
49230 }
49231
49232
49233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
49234   unsigned int jresult ;
49235   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49236   Dali::Rect< int > *arg2 = 0 ;
49237   bool result;
49238
49239   arg1 = (Dali::Rect< int > *)jarg1;
49240   arg2 = (Dali::Rect< int > *)jarg2;
49241   if (!arg2) {
49242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
49243     return 0;
49244   }
49245   {
49246     try {
49247       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
49248     } catch (std::out_of_range& e) {
49249       {
49250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49251       };
49252     } catch (std::exception& e) {
49253       {
49254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49255       };
49256     } catch (Dali::DaliException e) {
49257       {
49258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49259       };
49260     } catch (...) {
49261       {
49262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49263       };
49264     }
49265   }
49266
49267   jresult = result;
49268   return jresult;
49269 }
49270
49271
49272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
49273   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49274   int arg2 ;
49275
49276   arg1 = (Dali::Rect< int > *)jarg1;
49277   arg2 = (int)jarg2;
49278   if (arg1) (arg1)->x = arg2;
49279 }
49280
49281
49282 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
49283   int jresult ;
49284   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49285   int result;
49286
49287   arg1 = (Dali::Rect< int > *)jarg1;
49288   result = (int) ((arg1)->x);
49289   jresult = result;
49290   return jresult;
49291 }
49292
49293
49294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
49295   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49296   int arg2 ;
49297
49298   arg1 = (Dali::Rect< int > *)jarg1;
49299   arg2 = (int)jarg2;
49300   if (arg1) (arg1)->left = arg2;
49301 }
49302
49303
49304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
49305   int jresult ;
49306   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49307   int result;
49308
49309   arg1 = (Dali::Rect< int > *)jarg1;
49310   result = (int) ((arg1)->left);
49311   jresult = result;
49312   return jresult;
49313 }
49314
49315
49316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
49317   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49318   int arg2 ;
49319
49320   arg1 = (Dali::Rect< int > *)jarg1;
49321   arg2 = (int)jarg2;
49322   if (arg1) (arg1)->y = arg2;
49323 }
49324
49325
49326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
49327   int jresult ;
49328   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49329   int result;
49330
49331   arg1 = (Dali::Rect< int > *)jarg1;
49332   result = (int) ((arg1)->y);
49333   jresult = result;
49334   return jresult;
49335 }
49336
49337
49338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
49339   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49340   int arg2 ;
49341
49342   arg1 = (Dali::Rect< int > *)jarg1;
49343   arg2 = (int)jarg2;
49344   if (arg1) (arg1)->right = arg2;
49345 }
49346
49347
49348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
49349   int jresult ;
49350   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49351   int result;
49352
49353   arg1 = (Dali::Rect< int > *)jarg1;
49354   result = (int) ((arg1)->right);
49355   jresult = result;
49356   return jresult;
49357 }
49358
49359
49360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
49361   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49362   int arg2 ;
49363
49364   arg1 = (Dali::Rect< int > *)jarg1;
49365   arg2 = (int)jarg2;
49366   if (arg1) (arg1)->width = arg2;
49367 }
49368
49369
49370 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
49371   int jresult ;
49372   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49373   int result;
49374
49375   arg1 = (Dali::Rect< int > *)jarg1;
49376   result = (int) ((arg1)->width);
49377   jresult = result;
49378   return jresult;
49379 }
49380
49381
49382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
49383   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49384   int arg2 ;
49385
49386   arg1 = (Dali::Rect< int > *)jarg1;
49387   arg2 = (int)jarg2;
49388   if (arg1) (arg1)->bottom = arg2;
49389 }
49390
49391
49392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
49393   int jresult ;
49394   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49395   int result;
49396
49397   arg1 = (Dali::Rect< int > *)jarg1;
49398   result = (int) ((arg1)->bottom);
49399   jresult = result;
49400   return jresult;
49401 }
49402
49403
49404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
49405   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49406   int arg2 ;
49407
49408   arg1 = (Dali::Rect< int > *)jarg1;
49409   arg2 = (int)jarg2;
49410   if (arg1) (arg1)->height = arg2;
49411 }
49412
49413
49414 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
49415   int jresult ;
49416   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49417   int result;
49418
49419   arg1 = (Dali::Rect< int > *)jarg1;
49420   result = (int) ((arg1)->height);
49421   jresult = result;
49422   return jresult;
49423 }
49424
49425
49426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
49427   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49428   int arg2 ;
49429
49430   arg1 = (Dali::Rect< int > *)jarg1;
49431   arg2 = (int)jarg2;
49432   if (arg1) (arg1)->top = arg2;
49433 }
49434
49435
49436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
49437   int jresult ;
49438   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49439   int result;
49440
49441   arg1 = (Dali::Rect< int > *)jarg1;
49442   result = (int) ((arg1)->top);
49443   jresult = result;
49444   return jresult;
49445 }
49446
49447
49448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
49449   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
49450
49451   arg1 = (Dali::Rect< int > *)jarg1;
49452   {
49453     try {
49454       delete arg1;
49455     } catch (std::out_of_range& e) {
49456       {
49457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49458       };
49459     } catch (std::exception& e) {
49460       {
49461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49462       };
49463     } catch (Dali::DaliException e) {
49464       {
49465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49466       };
49467     } catch (...) {
49468       {
49469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49470       };
49471     }
49472   }
49473
49474 }
49475
49476
49477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
49478   void * jresult ;
49479   Dali::Rect< float > *result = 0 ;
49480
49481   {
49482     try {
49483       result = (Dali::Rect< float > *)new Dali::Rect< float >();
49484     } catch (std::out_of_range& e) {
49485       {
49486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49487       };
49488     } catch (std::exception& e) {
49489       {
49490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49491       };
49492     } catch (Dali::DaliException e) {
49493       {
49494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49495       };
49496     } catch (...) {
49497       {
49498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49499       };
49500     }
49501   }
49502
49503   jresult = (void *)result;
49504   return jresult;
49505 }
49506
49507
49508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
49509   void * jresult ;
49510   float arg1 ;
49511   float arg2 ;
49512   float arg3 ;
49513   float arg4 ;
49514   Dali::Rect< float > *result = 0 ;
49515
49516   arg1 = (float)jarg1;
49517   arg2 = (float)jarg2;
49518   arg3 = (float)jarg4;
49519   arg4 = (float)jarg3;
49520   {
49521     try {
49522       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
49523     } catch (std::out_of_range& e) {
49524       {
49525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49526       };
49527     } catch (std::exception& e) {
49528       {
49529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49530       };
49531     } catch (Dali::DaliException e) {
49532       {
49533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49534       };
49535     } catch (...) {
49536       {
49537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49538       };
49539     }
49540   }
49541
49542   jresult = (void *)result;
49543   return jresult;
49544 }
49545
49546
49547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
49548   void * jresult ;
49549   Dali::Rect< float > *arg1 = 0 ;
49550   Dali::Rect< float > *result = 0 ;
49551
49552   arg1 = (Dali::Rect< float > *)jarg1;
49553   if (!arg1) {
49554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
49555     return 0;
49556   }
49557   {
49558     try {
49559       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
49560     } catch (std::out_of_range& e) {
49561       {
49562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49563       };
49564     } catch (std::exception& e) {
49565       {
49566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49567       };
49568     } catch (Dali::DaliException e) {
49569       {
49570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49571       };
49572     } catch (...) {
49573       {
49574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49575       };
49576     }
49577   }
49578
49579   jresult = (void *)result;
49580   return jresult;
49581 }
49582
49583
49584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
49585   void * jresult ;
49586   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49587   Dali::Rect< float > *arg2 = 0 ;
49588   Dali::Rect< float > *result = 0 ;
49589
49590   arg1 = (Dali::Rect< float > *)jarg1;
49591   arg2 = (Dali::Rect< float > *)jarg2;
49592   if (!arg2) {
49593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
49594     return 0;
49595   }
49596   {
49597     try {
49598       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
49599     } catch (std::out_of_range& e) {
49600       {
49601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49602       };
49603     } catch (std::exception& e) {
49604       {
49605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49606       };
49607     } catch (Dali::DaliException e) {
49608       {
49609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49610       };
49611     } catch (...) {
49612       {
49613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49614       };
49615     }
49616   }
49617
49618   jresult = (void *)result;
49619   return jresult;
49620 }
49621
49622
49623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
49624   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49625   float arg2 ;
49626   float arg3 ;
49627   float arg4 ;
49628   float arg5 ;
49629
49630   arg1 = (Dali::Rect< float > *)jarg1;
49631   arg2 = (float)jarg2;
49632   arg3 = (float)jarg3;
49633   arg4 = (float)jarg5;
49634   arg5 = (float)jarg4;
49635   {
49636     try {
49637       (arg1)->Set(arg2,arg3,arg4,arg5);
49638     } catch (std::out_of_range& e) {
49639       {
49640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49641       };
49642     } catch (std::exception& e) {
49643       {
49644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49645       };
49646     } catch (Dali::DaliException e) {
49647       {
49648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49649       };
49650     } catch (...) {
49651       {
49652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49653       };
49654     }
49655   }
49656
49657 }
49658
49659
49660 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
49661   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49662   float arg2 ;
49663
49664   arg1 = (Dali::Rect< float > *)jarg1;
49665   arg2 = (float)jarg2;
49666   if (arg1) (arg1)->left = arg2;
49667 }
49668
49669
49670 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
49671   float jresult ;
49672   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49673   float result;
49674
49675   arg1 = (Dali::Rect< float > *)jarg1;
49676   result = (float) ((arg1)->left);
49677   jresult = result;
49678   return jresult;
49679 }
49680
49681
49682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
49683   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49684   float arg2 ;
49685
49686   arg1 = (Dali::Rect< float > *)jarg1;
49687   arg2 = (float)jarg2;
49688   if (arg1) (arg1)->left = arg2;
49689 }
49690
49691
49692 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
49693   float jresult ;
49694   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49695   float result;
49696
49697   arg1 = (Dali::Rect< float > *)jarg1;
49698   result = (float) ((arg1)->left);
49699   jresult = result;
49700   return jresult;
49701 }
49702
49703
49704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
49705   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49706   float arg2 ;
49707
49708   arg1 = (Dali::Rect< float > *)jarg1;
49709   arg2 = (float)jarg2;
49710   if (arg1) (arg1)->right = arg2;
49711 }
49712
49713
49714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
49715   float jresult ;
49716   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49717   float result;
49718
49719   arg1 = (Dali::Rect< float > *)jarg1;
49720   result = (float) ((arg1)->right);
49721   jresult = result;
49722   return jresult;
49723 }
49724
49725
49726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
49727   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49728   float arg2 ;
49729
49730   arg1 = (Dali::Rect< float > *)jarg1;
49731   arg2 = (float)jarg2;
49732   if (arg1) (arg1)->right = arg2;
49733 }
49734
49735
49736 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
49737   float jresult ;
49738   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49739   float result;
49740
49741   arg1 = (Dali::Rect< float > *)jarg1;
49742   result = (float) ((arg1)->right);
49743   jresult = result;
49744   return jresult;
49745 }
49746
49747
49748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
49749   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49750   float arg2 ;
49751
49752   arg1 = (Dali::Rect< float > *)jarg1;
49753   arg2 = (float)jarg2;
49754   if (arg1) (arg1)->bottom = arg2;
49755 }
49756
49757
49758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
49759   float jresult ;
49760   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49761   float result;
49762
49763   arg1 = (Dali::Rect< float > *)jarg1;
49764   result = (float) ((arg1)->bottom);
49765   jresult = result;
49766   return jresult;
49767 }
49768
49769
49770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
49771   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49772   float arg2 ;
49773
49774   arg1 = (Dali::Rect< float > *)jarg1;
49775   arg2 = (float)jarg2;
49776   if (arg1) (arg1)->top = arg2;
49777 }
49778
49779
49780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
49781   float jresult ;
49782   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49783   float result;
49784
49785   arg1 = (Dali::Rect< float > *)jarg1;
49786   result = (float) ((arg1)->top);
49787   jresult = result;
49788   return jresult;
49789 }
49790
49791
49792 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
49793   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
49794
49795   arg1 = (Dali::Rect< float > *)jarg1;
49796   {
49797     try {
49798       delete arg1;
49799     } catch (std::out_of_range& e) {
49800       {
49801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49802       };
49803     } catch (std::exception& e) {
49804       {
49805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49806       };
49807     } catch (Dali::DaliException e) {
49808       {
49809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49810       };
49811     } catch (...) {
49812       {
49813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49814       };
49815     }
49816   }
49817
49818 }
49819
49820
49821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
49822   int jresult ;
49823   int result;
49824
49825   result = (int)Dali::Vector< int >::BaseType;
49826   jresult = (int)result;
49827   return jresult;
49828 }
49829
49830
49831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
49832   void * jresult ;
49833   Dali::Vector< int > *result = 0 ;
49834
49835   {
49836     try {
49837       result = (Dali::Vector< int > *)new Dali::Vector< int >();
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 (Dali::DaliException e) {
49847       {
49848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49849       };
49850     } catch (...) {
49851       {
49852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49853       };
49854     }
49855   }
49856
49857   jresult = (void *)result;
49858   return jresult;
49859 }
49860
49861
49862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
49863   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49864
49865   arg1 = (Dali::Vector< int > *)jarg1;
49866   {
49867     try {
49868       delete arg1;
49869     } catch (std::out_of_range& e) {
49870       {
49871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49872       };
49873     } catch (std::exception& e) {
49874       {
49875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49876       };
49877     } catch (Dali::DaliException e) {
49878       {
49879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49880       };
49881     } catch (...) {
49882       {
49883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49884       };
49885     }
49886   }
49887
49888 }
49889
49890
49891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
49892   void * jresult ;
49893   Dali::Vector< int > *arg1 = 0 ;
49894   Dali::Vector< int > *result = 0 ;
49895
49896   arg1 = (Dali::Vector< int > *)jarg1;
49897   if (!arg1) {
49898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
49899     return 0;
49900   }
49901   {
49902     try {
49903       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
49904     } catch (std::out_of_range& e) {
49905       {
49906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49907       };
49908     } catch (std::exception& e) {
49909       {
49910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49911       };
49912     } catch (Dali::DaliException e) {
49913       {
49914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49915       };
49916     } catch (...) {
49917       {
49918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49919       };
49920     }
49921   }
49922
49923   jresult = (void *)result;
49924   return jresult;
49925 }
49926
49927
49928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
49929   void * jresult ;
49930   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49931   Dali::Vector< int > *arg2 = 0 ;
49932   Dali::Vector< int > *result = 0 ;
49933
49934   arg1 = (Dali::Vector< int > *)jarg1;
49935   arg2 = (Dali::Vector< int > *)jarg2;
49936   if (!arg2) {
49937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
49938     return 0;
49939   }
49940   {
49941     try {
49942       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
49943     } catch (std::out_of_range& e) {
49944       {
49945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49946       };
49947     } catch (std::exception& e) {
49948       {
49949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49950       };
49951     } catch (Dali::DaliException e) {
49952       {
49953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49954       };
49955     } catch (...) {
49956       {
49957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49958       };
49959     }
49960   }
49961
49962   jresult = (void *)result;
49963   return jresult;
49964 }
49965
49966
49967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
49968   void * jresult ;
49969   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
49970   Dali::Vector< int >::Iterator result;
49971
49972   arg1 = (Dali::Vector< int > *)jarg1;
49973   {
49974     try {
49975       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
49976     } catch (std::out_of_range& e) {
49977       {
49978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49979       };
49980     } catch (std::exception& e) {
49981       {
49982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49983       };
49984     } catch (Dali::DaliException e) {
49985       {
49986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49987       };
49988     } catch (...) {
49989       {
49990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49991       };
49992     }
49993   }
49994
49995   jresult = (void *)result;
49996   return jresult;
49997 }
49998
49999
50000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
50001   void * jresult ;
50002   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50003   Dali::Vector< int >::Iterator result;
50004
50005   arg1 = (Dali::Vector< int > *)jarg1;
50006   {
50007     try {
50008       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
50009     } catch (std::out_of_range& e) {
50010       {
50011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50012       };
50013     } catch (std::exception& e) {
50014       {
50015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50016       };
50017     } catch (Dali::DaliException e) {
50018       {
50019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50020       };
50021     } catch (...) {
50022       {
50023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50024       };
50025     }
50026   }
50027
50028   jresult = (void *)result;
50029   return jresult;
50030 }
50031
50032
50033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50034   void * jresult ;
50035   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50036   Dali::Vector< int >::SizeType arg2 ;
50037   Dali::Vector< int >::ItemType *result = 0 ;
50038
50039   arg1 = (Dali::Vector< int > *)jarg1;
50040   arg2 = (Dali::Vector< int >::SizeType)jarg2;
50041   {
50042     try {
50043       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
50044     } catch (std::out_of_range& e) {
50045       {
50046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50047       };
50048     } catch (std::exception& e) {
50049       {
50050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50051       };
50052     } catch (Dali::DaliException e) {
50053       {
50054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50055       };
50056     } catch (...) {
50057       {
50058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50059       };
50060     }
50061   }
50062
50063   jresult = (void *)result;
50064   return jresult;
50065 }
50066
50067
50068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
50069   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50070   Dali::Vector< int >::ItemType *arg2 = 0 ;
50071   Dali::Vector< int >::ItemType temp2 ;
50072
50073   arg1 = (Dali::Vector< int > *)jarg1;
50074   temp2 = (Dali::Vector< int >::ItemType)jarg2;
50075   arg2 = &temp2;
50076   {
50077     try {
50078       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
50079     } catch (std::out_of_range& e) {
50080       {
50081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50082       };
50083     } catch (std::exception& e) {
50084       {
50085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50086       };
50087     } catch (Dali::DaliException e) {
50088       {
50089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50090       };
50091     } catch (...) {
50092       {
50093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50094       };
50095     }
50096   }
50097
50098 }
50099
50100
50101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
50102   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50103   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
50104   Dali::Vector< int >::ItemType *arg3 = 0 ;
50105   Dali::Vector< int >::ItemType temp3 ;
50106
50107   arg1 = (Dali::Vector< int > *)jarg1;
50108   arg2 = (Dali::Vector< int >::Iterator)jarg2;
50109   temp3 = (Dali::Vector< int >::ItemType)jarg3;
50110   arg3 = &temp3;
50111   {
50112     try {
50113       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
50114     } catch (std::out_of_range& e) {
50115       {
50116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50117       };
50118     } catch (std::exception& e) {
50119       {
50120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50121       };
50122     } catch (Dali::DaliException e) {
50123       {
50124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50125       };
50126     } catch (...) {
50127       {
50128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50129       };
50130     }
50131   }
50132
50133 }
50134
50135
50136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
50137   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50138   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
50139   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
50140   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
50141
50142   arg1 = (Dali::Vector< int > *)jarg1;
50143   arg2 = (Dali::Vector< int >::Iterator)jarg2;
50144   arg3 = (Dali::Vector< int >::Iterator)jarg3;
50145   arg4 = (Dali::Vector< int >::Iterator)jarg4;
50146   {
50147     try {
50148       (arg1)->Insert(arg2,arg3,arg4);
50149     } catch (std::out_of_range& e) {
50150       {
50151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50152       };
50153     } catch (std::exception& e) {
50154       {
50155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50156       };
50157     } catch (Dali::DaliException e) {
50158       {
50159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50160       };
50161     } catch (...) {
50162       {
50163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50164       };
50165     }
50166   }
50167
50168 }
50169
50170
50171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
50172   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50173   Dali::Vector< int >::SizeType arg2 ;
50174
50175   arg1 = (Dali::Vector< int > *)jarg1;
50176   arg2 = (Dali::Vector< int >::SizeType)jarg2;
50177   {
50178     try {
50179       (arg1)->Reserve(arg2);
50180     } catch (std::out_of_range& e) {
50181       {
50182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50183       };
50184     } catch (std::exception& e) {
50185       {
50186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50187       };
50188     } catch (Dali::DaliException e) {
50189       {
50190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50191       };
50192     } catch (...) {
50193       {
50194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50195       };
50196     }
50197   }
50198
50199 }
50200
50201
50202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50203   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50204   Dali::Vector< int >::SizeType arg2 ;
50205
50206   arg1 = (Dali::Vector< int > *)jarg1;
50207   arg2 = (Dali::Vector< int >::SizeType)jarg2;
50208   {
50209     try {
50210       (arg1)->Resize(arg2);
50211     } catch (std::out_of_range& e) {
50212       {
50213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50214       };
50215     } catch (std::exception& e) {
50216       {
50217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50218       };
50219     } catch (Dali::DaliException e) {
50220       {
50221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50222       };
50223     } catch (...) {
50224       {
50225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50226       };
50227     }
50228   }
50229
50230 }
50231
50232
50233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
50234   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50235   Dali::Vector< int >::SizeType arg2 ;
50236   Dali::Vector< int >::ItemType *arg3 = 0 ;
50237   Dali::Vector< int >::ItemType temp3 ;
50238
50239   arg1 = (Dali::Vector< int > *)jarg1;
50240   arg2 = (Dali::Vector< int >::SizeType)jarg2;
50241   temp3 = (Dali::Vector< int >::ItemType)jarg3;
50242   arg3 = &temp3;
50243   {
50244     try {
50245       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
50246     } catch (std::out_of_range& e) {
50247       {
50248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50249       };
50250     } catch (std::exception& e) {
50251       {
50252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50253       };
50254     } catch (Dali::DaliException e) {
50255       {
50256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50257       };
50258     } catch (...) {
50259       {
50260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50261       };
50262     }
50263   }
50264
50265 }
50266
50267
50268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
50269   void * jresult ;
50270   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50271   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
50272   Dali::Vector< int >::Iterator result;
50273
50274   arg1 = (Dali::Vector< int > *)jarg1;
50275   arg2 = (Dali::Vector< int >::Iterator)jarg2;
50276   {
50277     try {
50278       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
50279     } catch (std::out_of_range& e) {
50280       {
50281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50282       };
50283     } catch (std::exception& e) {
50284       {
50285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50286       };
50287     } catch (Dali::DaliException e) {
50288       {
50289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50290       };
50291     } catch (...) {
50292       {
50293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50294       };
50295     }
50296   }
50297
50298   jresult = (void *)result;
50299   return jresult;
50300 }
50301
50302
50303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50304   void * jresult ;
50305   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50306   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
50307   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
50308   Dali::Vector< int >::Iterator result;
50309
50310   arg1 = (Dali::Vector< int > *)jarg1;
50311   arg2 = (Dali::Vector< int >::Iterator)jarg2;
50312   arg3 = (Dali::Vector< int >::Iterator)jarg3;
50313   {
50314     try {
50315       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
50316     } catch (std::out_of_range& e) {
50317       {
50318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50319       };
50320     } catch (std::exception& e) {
50321       {
50322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50323       };
50324     } catch (Dali::DaliException e) {
50325       {
50326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50327       };
50328     } catch (...) {
50329       {
50330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50331       };
50332     }
50333   }
50334
50335   jresult = (void *)result;
50336   return jresult;
50337 }
50338
50339
50340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
50341   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50342   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
50343
50344   arg1 = (Dali::Vector< int > *)jarg1;
50345   arg2 = (Dali::Vector< int >::Iterator)jarg2;
50346   {
50347     try {
50348       (arg1)->Remove(arg2);
50349     } catch (std::out_of_range& e) {
50350       {
50351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50352       };
50353     } catch (std::exception& e) {
50354       {
50355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50356       };
50357     } catch (Dali::DaliException e) {
50358       {
50359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50360       };
50361     } catch (...) {
50362       {
50363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50364       };
50365     }
50366   }
50367
50368 }
50369
50370
50371 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
50372   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50373   Dali::Vector< int > *arg2 = 0 ;
50374
50375   arg1 = (Dali::Vector< int > *)jarg1;
50376   arg2 = (Dali::Vector< int > *)jarg2;
50377   if (!arg2) {
50378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
50379     return ;
50380   }
50381   {
50382     try {
50383       (arg1)->Swap(*arg2);
50384     } catch (std::out_of_range& e) {
50385       {
50386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50387       };
50388     } catch (std::exception& e) {
50389       {
50390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50391       };
50392     } catch (Dali::DaliException e) {
50393       {
50394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50395       };
50396     } catch (...) {
50397       {
50398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50399       };
50400     }
50401   }
50402
50403 }
50404
50405
50406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
50407   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50408
50409   arg1 = (Dali::Vector< int > *)jarg1;
50410   {
50411     try {
50412       (arg1)->Clear();
50413     } catch (std::out_of_range& e) {
50414       {
50415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50416       };
50417     } catch (std::exception& e) {
50418       {
50419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50420       };
50421     } catch (Dali::DaliException e) {
50422       {
50423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50424       };
50425     } catch (...) {
50426       {
50427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50428       };
50429     }
50430   }
50431
50432 }
50433
50434
50435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
50436   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
50437
50438   arg1 = (Dali::Vector< int > *)jarg1;
50439   {
50440     try {
50441       (arg1)->Release();
50442     } catch (std::out_of_range& e) {
50443       {
50444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50445       };
50446     } catch (std::exception& e) {
50447       {
50448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50449       };
50450     } catch (Dali::DaliException e) {
50451       {
50452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50453       };
50454     } catch (...) {
50455       {
50456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50457       };
50458     }
50459   }
50460
50461 }
50462
50463
50464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
50465   int jresult ;
50466   int result;
50467
50468   result = (int)Dali::Vector< float >::BaseType;
50469   jresult = (int)result;
50470   return jresult;
50471 }
50472
50473
50474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
50475   void * jresult ;
50476   Dali::Vector< float > *result = 0 ;
50477
50478   {
50479     try {
50480       result = (Dali::Vector< float > *)new Dali::Vector< float >();
50481     } catch (std::out_of_range& e) {
50482       {
50483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50484       };
50485     } catch (std::exception& e) {
50486       {
50487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50488       };
50489     } catch (Dali::DaliException e) {
50490       {
50491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50492       };
50493     } catch (...) {
50494       {
50495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50496       };
50497     }
50498   }
50499
50500   jresult = (void *)result;
50501   return jresult;
50502 }
50503
50504
50505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
50506   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50507
50508   arg1 = (Dali::Vector< float > *)jarg1;
50509   {
50510     try {
50511       delete arg1;
50512     } catch (std::out_of_range& e) {
50513       {
50514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50515       };
50516     } catch (std::exception& e) {
50517       {
50518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50519       };
50520     } catch (Dali::DaliException e) {
50521       {
50522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50523       };
50524     } catch (...) {
50525       {
50526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50527       };
50528     }
50529   }
50530
50531 }
50532
50533
50534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
50535   void * jresult ;
50536   Dali::Vector< float > *arg1 = 0 ;
50537   Dali::Vector< float > *result = 0 ;
50538
50539   arg1 = (Dali::Vector< float > *)jarg1;
50540   if (!arg1) {
50541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
50542     return 0;
50543   }
50544   {
50545     try {
50546       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
50547     } catch (std::out_of_range& e) {
50548       {
50549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50550       };
50551     } catch (std::exception& e) {
50552       {
50553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50554       };
50555     } catch (Dali::DaliException e) {
50556       {
50557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50558       };
50559     } catch (...) {
50560       {
50561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50562       };
50563     }
50564   }
50565
50566   jresult = (void *)result;
50567   return jresult;
50568 }
50569
50570
50571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
50572   void * jresult ;
50573   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50574   Dali::Vector< float > *arg2 = 0 ;
50575   Dali::Vector< float > *result = 0 ;
50576
50577   arg1 = (Dali::Vector< float > *)jarg1;
50578   arg2 = (Dali::Vector< float > *)jarg2;
50579   if (!arg2) {
50580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
50581     return 0;
50582   }
50583   {
50584     try {
50585       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
50586     } catch (std::out_of_range& e) {
50587       {
50588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50589       };
50590     } catch (std::exception& e) {
50591       {
50592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50593       };
50594     } catch (Dali::DaliException e) {
50595       {
50596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50597       };
50598     } catch (...) {
50599       {
50600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50601       };
50602     }
50603   }
50604
50605   jresult = (void *)result;
50606   return jresult;
50607 }
50608
50609
50610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
50611   void * jresult ;
50612   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50613   Dali::Vector< float >::Iterator result;
50614
50615   arg1 = (Dali::Vector< float > *)jarg1;
50616   {
50617     try {
50618       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
50619     } catch (std::out_of_range& e) {
50620       {
50621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50622       };
50623     } catch (std::exception& e) {
50624       {
50625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50626       };
50627     } catch (Dali::DaliException e) {
50628       {
50629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50630       };
50631     } catch (...) {
50632       {
50633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50634       };
50635     }
50636   }
50637
50638   jresult = (void *)result;
50639   return jresult;
50640 }
50641
50642
50643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
50644   void * jresult ;
50645   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50646   Dali::Vector< float >::Iterator result;
50647
50648   arg1 = (Dali::Vector< float > *)jarg1;
50649   {
50650     try {
50651       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
50652     } catch (std::out_of_range& e) {
50653       {
50654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50655       };
50656     } catch (std::exception& e) {
50657       {
50658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50659       };
50660     } catch (Dali::DaliException e) {
50661       {
50662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50663       };
50664     } catch (...) {
50665       {
50666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50667       };
50668     }
50669   }
50670
50671   jresult = (void *)result;
50672   return jresult;
50673 }
50674
50675
50676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50677   void * jresult ;
50678   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50679   Dali::Vector< float >::SizeType arg2 ;
50680   Dali::Vector< float >::ItemType *result = 0 ;
50681
50682   arg1 = (Dali::Vector< float > *)jarg1;
50683   arg2 = (Dali::Vector< float >::SizeType)jarg2;
50684   {
50685     try {
50686       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
50687     } catch (std::out_of_range& e) {
50688       {
50689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50690       };
50691     } catch (std::exception& e) {
50692       {
50693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50694       };
50695     } catch (Dali::DaliException e) {
50696       {
50697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50698       };
50699     } catch (...) {
50700       {
50701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50702       };
50703     }
50704   }
50705
50706   jresult = (void *)result;
50707   return jresult;
50708 }
50709
50710
50711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
50712   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50713   Dali::Vector< float >::ItemType *arg2 = 0 ;
50714   Dali::Vector< float >::ItemType temp2 ;
50715
50716   arg1 = (Dali::Vector< float > *)jarg1;
50717   temp2 = (Dali::Vector< float >::ItemType)jarg2;
50718   arg2 = &temp2;
50719   {
50720     try {
50721       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
50722     } catch (std::out_of_range& e) {
50723       {
50724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50725       };
50726     } catch (std::exception& e) {
50727       {
50728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50729       };
50730     } catch (Dali::DaliException e) {
50731       {
50732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50733       };
50734     } catch (...) {
50735       {
50736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50737       };
50738     }
50739   }
50740
50741 }
50742
50743
50744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
50745   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50746   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
50747   Dali::Vector< float >::ItemType *arg3 = 0 ;
50748   Dali::Vector< float >::ItemType temp3 ;
50749
50750   arg1 = (Dali::Vector< float > *)jarg1;
50751   arg2 = (Dali::Vector< float >::Iterator)jarg2;
50752   temp3 = (Dali::Vector< float >::ItemType)jarg3;
50753   arg3 = &temp3;
50754   {
50755     try {
50756       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
50757     } catch (std::out_of_range& e) {
50758       {
50759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50760       };
50761     } catch (std::exception& e) {
50762       {
50763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50764       };
50765     } catch (Dali::DaliException e) {
50766       {
50767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50768       };
50769     } catch (...) {
50770       {
50771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50772       };
50773     }
50774   }
50775
50776 }
50777
50778
50779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
50780   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50781   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
50782   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
50783   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
50784
50785   arg1 = (Dali::Vector< float > *)jarg1;
50786   arg2 = (Dali::Vector< float >::Iterator)jarg2;
50787   arg3 = (Dali::Vector< float >::Iterator)jarg3;
50788   arg4 = (Dali::Vector< float >::Iterator)jarg4;
50789   {
50790     try {
50791       (arg1)->Insert(arg2,arg3,arg4);
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 (Dali::DaliException e) {
50801       {
50802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50803       };
50804     } catch (...) {
50805       {
50806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50807       };
50808     }
50809   }
50810
50811 }
50812
50813
50814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
50815   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50816   Dali::Vector< float >::SizeType arg2 ;
50817
50818   arg1 = (Dali::Vector< float > *)jarg1;
50819   arg2 = (Dali::Vector< float >::SizeType)jarg2;
50820   {
50821     try {
50822       (arg1)->Reserve(arg2);
50823     } catch (std::out_of_range& e) {
50824       {
50825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50826       };
50827     } catch (std::exception& e) {
50828       {
50829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50830       };
50831     } catch (Dali::DaliException e) {
50832       {
50833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50834       };
50835     } catch (...) {
50836       {
50837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50838       };
50839     }
50840   }
50841
50842 }
50843
50844 //// ========================= end of part 2 =============================
50845
50846 //// ========================== start part 3 ===============================
50847
50848
50849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50850   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50851   Dali::Vector< float >::SizeType arg2 ;
50852
50853   arg1 = (Dali::Vector< float > *)jarg1;
50854   arg2 = (Dali::Vector< float >::SizeType)jarg2;
50855   {
50856     try {
50857       (arg1)->Resize(arg2);
50858     } catch (std::out_of_range& e) {
50859       {
50860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50861       };
50862     } catch (std::exception& e) {
50863       {
50864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50865       };
50866     } catch (Dali::DaliException e) {
50867       {
50868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50869       };
50870     } catch (...) {
50871       {
50872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50873       };
50874     }
50875   }
50876
50877 }
50878
50879
50880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
50881   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50882   Dali::Vector< float >::SizeType arg2 ;
50883   Dali::Vector< float >::ItemType *arg3 = 0 ;
50884   Dali::Vector< float >::ItemType temp3 ;
50885
50886   arg1 = (Dali::Vector< float > *)jarg1;
50887   arg2 = (Dali::Vector< float >::SizeType)jarg2;
50888   temp3 = (Dali::Vector< float >::ItemType)jarg3;
50889   arg3 = &temp3;
50890   {
50891     try {
50892       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
50893     } catch (std::out_of_range& e) {
50894       {
50895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50896       };
50897     } catch (std::exception& e) {
50898       {
50899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50900       };
50901     } catch (Dali::DaliException e) {
50902       {
50903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50904       };
50905     } catch (...) {
50906       {
50907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50908       };
50909     }
50910   }
50911
50912 }
50913
50914
50915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
50916   void * jresult ;
50917   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50918   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
50919   Dali::Vector< float >::Iterator result;
50920
50921   arg1 = (Dali::Vector< float > *)jarg1;
50922   arg2 = (Dali::Vector< float >::Iterator)jarg2;
50923   {
50924     try {
50925       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
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 (Dali::DaliException e) {
50935       {
50936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50937       };
50938     } catch (...) {
50939       {
50940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50941       };
50942     }
50943   }
50944
50945   jresult = (void *)result;
50946   return jresult;
50947 }
50948
50949
50950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50951   void * jresult ;
50952   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50953   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
50954   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
50955   Dali::Vector< float >::Iterator result;
50956
50957   arg1 = (Dali::Vector< float > *)jarg1;
50958   arg2 = (Dali::Vector< float >::Iterator)jarg2;
50959   arg3 = (Dali::Vector< float >::Iterator)jarg3;
50960   {
50961     try {
50962       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
50963     } catch (std::out_of_range& e) {
50964       {
50965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50966       };
50967     } catch (std::exception& e) {
50968       {
50969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50970       };
50971     } catch (Dali::DaliException e) {
50972       {
50973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50974       };
50975     } catch (...) {
50976       {
50977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50978       };
50979     }
50980   }
50981
50982   jresult = (void *)result;
50983   return jresult;
50984 }
50985
50986
50987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
50988   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
50989   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
50990
50991   arg1 = (Dali::Vector< float > *)jarg1;
50992   arg2 = (Dali::Vector< float >::Iterator)jarg2;
50993   {
50994     try {
50995       (arg1)->Remove(arg2);
50996     } catch (std::out_of_range& e) {
50997       {
50998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50999       };
51000     } catch (std::exception& e) {
51001       {
51002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51003       };
51004     } catch (Dali::DaliException e) {
51005       {
51006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51007       };
51008     } catch (...) {
51009       {
51010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51011       };
51012     }
51013   }
51014
51015 }
51016
51017
51018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
51019   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51020   Dali::Vector< float > *arg2 = 0 ;
51021
51022   arg1 = (Dali::Vector< float > *)jarg1;
51023   arg2 = (Dali::Vector< float > *)jarg2;
51024   if (!arg2) {
51025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
51026     return ;
51027   }
51028   {
51029     try {
51030       (arg1)->Swap(*arg2);
51031     } catch (std::out_of_range& e) {
51032       {
51033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51034       };
51035     } catch (std::exception& e) {
51036       {
51037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51038       };
51039     } catch (Dali::DaliException e) {
51040       {
51041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51042       };
51043     } catch (...) {
51044       {
51045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51046       };
51047     }
51048   }
51049
51050 }
51051
51052
51053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
51054   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51055
51056   arg1 = (Dali::Vector< float > *)jarg1;
51057   {
51058     try {
51059       (arg1)->Clear();
51060     } catch (std::out_of_range& e) {
51061       {
51062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51063       };
51064     } catch (std::exception& e) {
51065       {
51066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51067       };
51068     } catch (Dali::DaliException e) {
51069       {
51070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51071       };
51072     } catch (...) {
51073       {
51074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51075       };
51076     }
51077   }
51078
51079 }
51080
51081
51082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
51083   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
51084
51085   arg1 = (Dali::Vector< float > *)jarg1;
51086   {
51087     try {
51088       (arg1)->Release();
51089     } catch (std::out_of_range& e) {
51090       {
51091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51092       };
51093     } catch (std::exception& e) {
51094       {
51095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51096       };
51097     } catch (Dali::DaliException e) {
51098       {
51099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51100       };
51101     } catch (...) {
51102       {
51103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51104       };
51105     }
51106   }
51107
51108 }
51109
51110
51111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
51112   int jresult ;
51113   int result;
51114
51115   result = (int)Dali::Vector< unsigned char >::BaseType;
51116   jresult = (int)result;
51117   return jresult;
51118 }
51119
51120
51121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
51122   void * jresult ;
51123   Dali::Vector< unsigned char > *result = 0 ;
51124
51125   {
51126     try {
51127       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
51128     } catch (std::out_of_range& e) {
51129       {
51130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51131       };
51132     } catch (std::exception& e) {
51133       {
51134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51135       };
51136     } catch (Dali::DaliException e) {
51137       {
51138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51139       };
51140     } catch (...) {
51141       {
51142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51143       };
51144     }
51145   }
51146
51147   jresult = (void *)result;
51148   return jresult;
51149 }
51150
51151
51152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
51153   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51154
51155   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51156   {
51157     try {
51158       delete arg1;
51159     } catch (std::out_of_range& e) {
51160       {
51161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51162       };
51163     } catch (std::exception& e) {
51164       {
51165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51166       };
51167     } catch (Dali::DaliException e) {
51168       {
51169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51170       };
51171     } catch (...) {
51172       {
51173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51174       };
51175     }
51176   }
51177
51178 }
51179
51180
51181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
51182   void * jresult ;
51183   Dali::Vector< unsigned char > *arg1 = 0 ;
51184   Dali::Vector< unsigned char > *result = 0 ;
51185
51186   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51187   if (!arg1) {
51188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
51189     return 0;
51190   }
51191   {
51192     try {
51193       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
51194     } catch (std::out_of_range& e) {
51195       {
51196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51197       };
51198     } catch (std::exception& e) {
51199       {
51200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51201       };
51202     } catch (Dali::DaliException e) {
51203       {
51204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51205       };
51206     } catch (...) {
51207       {
51208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51209       };
51210     }
51211   }
51212
51213   jresult = (void *)result;
51214   return jresult;
51215 }
51216
51217
51218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
51219   void * jresult ;
51220   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51221   Dali::Vector< unsigned char > *arg2 = 0 ;
51222   Dali::Vector< unsigned char > *result = 0 ;
51223
51224   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51225   arg2 = (Dali::Vector< unsigned char > *)jarg2;
51226   if (!arg2) {
51227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
51228     return 0;
51229   }
51230   {
51231     try {
51232       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
51233     } catch (std::out_of_range& e) {
51234       {
51235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51236       };
51237     } catch (std::exception& e) {
51238       {
51239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51240       };
51241     } catch (Dali::DaliException e) {
51242       {
51243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51244       };
51245     } catch (...) {
51246       {
51247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51248       };
51249     }
51250   }
51251
51252   jresult = (void *)result;
51253   return jresult;
51254 }
51255
51256
51257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
51258   void * jresult ;
51259   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51260   Dali::Vector< unsigned char >::Iterator result;
51261
51262   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51263   {
51264     try {
51265       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
51266     } catch (std::out_of_range& e) {
51267       {
51268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51269       };
51270     } catch (std::exception& e) {
51271       {
51272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51273       };
51274     } catch (Dali::DaliException e) {
51275       {
51276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51277       };
51278     } catch (...) {
51279       {
51280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51281       };
51282     }
51283   }
51284
51285   jresult = (void *)result;
51286   return jresult;
51287 }
51288
51289
51290 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
51291   void * jresult ;
51292   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51293   Dali::Vector< unsigned char >::Iterator result;
51294
51295   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51296   {
51297     try {
51298       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
51299     } catch (std::out_of_range& e) {
51300       {
51301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51302       };
51303     } catch (std::exception& e) {
51304       {
51305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51306       };
51307     } catch (Dali::DaliException e) {
51308       {
51309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51310       };
51311     } catch (...) {
51312       {
51313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51314       };
51315     }
51316   }
51317
51318   jresult = (void *)result;
51319   return jresult;
51320 }
51321
51322
51323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51324   void * jresult ;
51325   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51326   Dali::Vector< unsigned char >::SizeType arg2 ;
51327   Dali::Vector< unsigned char >::ItemType *result = 0 ;
51328
51329   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51330   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
51331   {
51332     try {
51333       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
51334     } catch (std::out_of_range& e) {
51335       {
51336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51337       };
51338     } catch (std::exception& e) {
51339       {
51340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51341       };
51342     } catch (Dali::DaliException e) {
51343       {
51344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51345       };
51346     } catch (...) {
51347       {
51348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51349       };
51350     }
51351   }
51352
51353   jresult = (void *)result;
51354   return jresult;
51355 }
51356
51357
51358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
51359   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51360   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
51361   Dali::Vector< unsigned char >::ItemType temp2 ;
51362
51363   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51364   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
51365   arg2 = &temp2;
51366   {
51367     try {
51368       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
51369     } catch (std::out_of_range& e) {
51370       {
51371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51372       };
51373     } catch (std::exception& e) {
51374       {
51375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51376       };
51377     } catch (Dali::DaliException e) {
51378       {
51379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51380       };
51381     } catch (...) {
51382       {
51383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51384       };
51385     }
51386   }
51387
51388 }
51389
51390
51391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
51392   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51393   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51394   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
51395   Dali::Vector< unsigned char >::ItemType temp3 ;
51396
51397   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51398   arg2 = jarg2;
51399   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
51400   arg3 = &temp3;
51401   {
51402     try {
51403       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
51404     } catch (std::out_of_range& e) {
51405       {
51406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51407       };
51408     } catch (std::exception& e) {
51409       {
51410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51411       };
51412     } catch (Dali::DaliException e) {
51413       {
51414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51415       };
51416     } catch (...) {
51417       {
51418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51419       };
51420     }
51421   }
51422
51423
51424
51425 }
51426
51427
51428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
51429   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51430   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51431   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51432   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51433
51434   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51435   arg2 = jarg2;
51436   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
51437   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
51438   {
51439     try {
51440       (arg1)->Insert(arg2,arg3,arg4);
51441     } catch (std::out_of_range& e) {
51442       {
51443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51444       };
51445     } catch (std::exception& e) {
51446       {
51447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51448       };
51449     } catch (Dali::DaliException e) {
51450       {
51451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51452       };
51453     } catch (...) {
51454       {
51455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51456       };
51457     }
51458   }
51459
51460
51461
51462 }
51463
51464
51465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
51466   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51467   Dali::Vector< unsigned char >::SizeType arg2 ;
51468
51469   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51470   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
51471   {
51472     try {
51473       (arg1)->Reserve(arg2);
51474     } catch (std::out_of_range& e) {
51475       {
51476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51477       };
51478     } catch (std::exception& e) {
51479       {
51480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51481       };
51482     } catch (Dali::DaliException e) {
51483       {
51484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51485       };
51486     } catch (...) {
51487       {
51488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51489       };
51490     }
51491   }
51492
51493 }
51494
51495
51496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
51497   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51498   Dali::Vector< unsigned char >::SizeType arg2 ;
51499
51500   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51501   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
51502   {
51503     try {
51504       (arg1)->Resize(arg2);
51505     } catch (std::out_of_range& e) {
51506       {
51507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51508       };
51509     } catch (std::exception& e) {
51510       {
51511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51512       };
51513     } catch (Dali::DaliException e) {
51514       {
51515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51516       };
51517     } catch (...) {
51518       {
51519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51520       };
51521     }
51522   }
51523
51524 }
51525
51526
51527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
51528   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51529   Dali::Vector< unsigned char >::SizeType arg2 ;
51530   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
51531   Dali::Vector< unsigned char >::ItemType temp3 ;
51532
51533   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51534   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
51535   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
51536   arg3 = &temp3;
51537   {
51538     try {
51539       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
51540     } catch (std::out_of_range& e) {
51541       {
51542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51543       };
51544     } catch (std::exception& e) {
51545       {
51546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51547       };
51548     } catch (Dali::DaliException e) {
51549       {
51550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51551       };
51552     } catch (...) {
51553       {
51554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51555       };
51556     }
51557   }
51558
51559 }
51560
51561
51562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
51563   void * jresult ;
51564   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51565   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51566   Dali::Vector< unsigned char >::Iterator result;
51567
51568   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51569   arg2 = jarg2;
51570   {
51571     try {
51572       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
51573     } catch (std::out_of_range& e) {
51574       {
51575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51576       };
51577     } catch (std::exception& e) {
51578       {
51579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51580       };
51581     } catch (Dali::DaliException e) {
51582       {
51583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51584       };
51585     } catch (...) {
51586       {
51587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51588       };
51589     }
51590   }
51591
51592   jresult = (void *)result;
51593
51594
51595   return jresult;
51596 }
51597
51598
51599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
51600   void * jresult ;
51601   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51602   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51603   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51604   Dali::Vector< unsigned char >::Iterator result;
51605
51606   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51607   arg2 = jarg2;
51608   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
51609   {
51610     try {
51611       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
51612     } catch (std::out_of_range& e) {
51613       {
51614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51615       };
51616     } catch (std::exception& e) {
51617       {
51618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51619       };
51620     } catch (Dali::DaliException e) {
51621       {
51622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51623       };
51624     } catch (...) {
51625       {
51626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51627       };
51628     }
51629   }
51630
51631   jresult = (void *)result;
51632
51633
51634   return jresult;
51635 }
51636
51637
51638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
51639   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51640   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
51641
51642   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51643   arg2 = jarg2;
51644   {
51645     try {
51646       (arg1)->Remove(arg2);
51647     } catch (std::out_of_range& e) {
51648       {
51649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51650       };
51651     } catch (std::exception& e) {
51652       {
51653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51654       };
51655     } catch (Dali::DaliException e) {
51656       {
51657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51658       };
51659     } catch (...) {
51660       {
51661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51662       };
51663     }
51664   }
51665
51666
51667
51668 }
51669
51670
51671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
51672   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51673   Dali::Vector< unsigned char > *arg2 = 0 ;
51674
51675   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51676   arg2 = (Dali::Vector< unsigned char > *)jarg2;
51677   if (!arg2) {
51678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
51679     return ;
51680   }
51681   {
51682     try {
51683       (arg1)->Swap(*arg2);
51684     } catch (std::out_of_range& e) {
51685       {
51686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51687       };
51688     } catch (std::exception& e) {
51689       {
51690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51691       };
51692     } catch (Dali::DaliException e) {
51693       {
51694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51695       };
51696     } catch (...) {
51697       {
51698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51699       };
51700     }
51701   }
51702
51703 }
51704
51705
51706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
51707   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51708
51709   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51710   {
51711     try {
51712       (arg1)->Clear();
51713     } catch (std::out_of_range& e) {
51714       {
51715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51716       };
51717     } catch (std::exception& e) {
51718       {
51719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51720       };
51721     } catch (Dali::DaliException e) {
51722       {
51723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51724       };
51725     } catch (...) {
51726       {
51727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51728       };
51729     }
51730   }
51731
51732 }
51733
51734
51735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
51736   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
51737
51738   arg1 = (Dali::Vector< unsigned char > *)jarg1;
51739   {
51740     try {
51741       (arg1)->Release();
51742     } catch (std::out_of_range& e) {
51743       {
51744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51745       };
51746     } catch (std::exception& e) {
51747       {
51748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51749       };
51750     } catch (Dali::DaliException e) {
51751       {
51752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51753       };
51754     } catch (...) {
51755       {
51756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51757       };
51758     }
51759   }
51760
51761 }
51762
51763
51764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
51765   int jresult ;
51766   int result;
51767
51768   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
51769   jresult = (int)result;
51770   return jresult;
51771 }
51772
51773
51774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
51775   void * jresult ;
51776   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
51777
51778   {
51779     try {
51780       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
51781     } catch (std::out_of_range& e) {
51782       {
51783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51784       };
51785     } catch (std::exception& e) {
51786       {
51787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51788       };
51789     } catch (Dali::DaliException e) {
51790       {
51791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51792       };
51793     } catch (...) {
51794       {
51795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51796       };
51797     }
51798   }
51799
51800   jresult = (void *)result;
51801   return jresult;
51802 }
51803
51804
51805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
51806   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51807
51808   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51809   {
51810     try {
51811       delete arg1;
51812     } catch (std::out_of_range& e) {
51813       {
51814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51815       };
51816     } catch (std::exception& e) {
51817       {
51818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51819       };
51820     } catch (Dali::DaliException e) {
51821       {
51822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51823       };
51824     } catch (...) {
51825       {
51826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51827       };
51828     }
51829   }
51830
51831 }
51832
51833
51834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
51835   void * jresult ;
51836   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
51837   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
51838
51839   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51840   if (!arg1) {
51841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
51842     return 0;
51843   }
51844   {
51845     try {
51846       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
51847     } catch (std::out_of_range& e) {
51848       {
51849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51850       };
51851     } catch (std::exception& e) {
51852       {
51853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51854       };
51855     } catch (Dali::DaliException e) {
51856       {
51857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51858       };
51859     } catch (...) {
51860       {
51861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51862       };
51863     }
51864   }
51865
51866   jresult = (void *)result;
51867   return jresult;
51868 }
51869
51870
51871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
51872   void * jresult ;
51873   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51874   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
51875   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
51876
51877   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51878   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
51879   if (!arg2) {
51880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
51881     return 0;
51882   }
51883   {
51884     try {
51885       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
51886     } catch (std::out_of_range& e) {
51887       {
51888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51889       };
51890     } catch (std::exception& e) {
51891       {
51892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51893       };
51894     } catch (Dali::DaliException e) {
51895       {
51896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51897       };
51898     } catch (...) {
51899       {
51900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51901       };
51902     }
51903   }
51904
51905   jresult = (void *)result;
51906   return jresult;
51907 }
51908
51909
51910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
51911   void * jresult ;
51912   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51913   Dali::Vector< Dali::Uint16Pair >::Iterator result;
51914
51915   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51916   {
51917     try {
51918       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
51919     } catch (std::out_of_range& e) {
51920       {
51921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51922       };
51923     } catch (std::exception& e) {
51924       {
51925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51926       };
51927     } catch (Dali::DaliException e) {
51928       {
51929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51930       };
51931     } catch (...) {
51932       {
51933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51934       };
51935     }
51936   }
51937
51938   jresult = (void *)result;
51939   return jresult;
51940 }
51941
51942
51943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
51944   void * jresult ;
51945   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51946   Dali::Vector< Dali::Uint16Pair >::Iterator result;
51947
51948   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51949   {
51950     try {
51951       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
51952     } catch (std::out_of_range& e) {
51953       {
51954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51955       };
51956     } catch (std::exception& e) {
51957       {
51958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51959       };
51960     } catch (Dali::DaliException e) {
51961       {
51962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51963       };
51964     } catch (...) {
51965       {
51966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51967       };
51968     }
51969   }
51970
51971   jresult = (void *)result;
51972   return jresult;
51973 }
51974
51975
51976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
51977   void * jresult ;
51978   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
51979   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
51980   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
51981
51982   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
51983   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
51984   {
51985     try {
51986       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
51987     } catch (std::out_of_range& e) {
51988       {
51989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51990       };
51991     } catch (std::exception& e) {
51992       {
51993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51994       };
51995     } catch (Dali::DaliException e) {
51996       {
51997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51998       };
51999     } catch (...) {
52000       {
52001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52002       };
52003     }
52004   }
52005
52006   jresult = (void *)result;
52007   return jresult;
52008 }
52009
52010
52011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
52012   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52013   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
52014
52015   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52016   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
52017   if (!arg2) {
52018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
52019     return ;
52020   }
52021   {
52022     try {
52023       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
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 (Dali::DaliException e) {
52033       {
52034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52035       };
52036     } catch (...) {
52037       {
52038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52039       };
52040     }
52041   }
52042
52043 }
52044
52045
52046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
52047   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52048   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
52049   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
52050
52051   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52052   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
52053   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
52054   if (!arg3) {
52055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
52056     return ;
52057   }
52058   {
52059     try {
52060       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
52061     } catch (std::out_of_range& e) {
52062       {
52063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52064       };
52065     } catch (std::exception& e) {
52066       {
52067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52068       };
52069     } catch (Dali::DaliException e) {
52070       {
52071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52072       };
52073     } catch (...) {
52074       {
52075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52076       };
52077     }
52078   }
52079
52080 }
52081
52082
52083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
52084   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52085   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
52086   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
52087   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
52088
52089   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52090   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
52091   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
52092   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
52093   {
52094     try {
52095       (arg1)->Insert(arg2,arg3,arg4);
52096     } catch (std::out_of_range& e) {
52097       {
52098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52099       };
52100     } catch (std::exception& e) {
52101       {
52102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52103       };
52104     } catch (Dali::DaliException e) {
52105       {
52106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52107       };
52108     } catch (...) {
52109       {
52110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52111       };
52112     }
52113   }
52114
52115 }
52116
52117
52118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
52119   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52120   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
52121
52122   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52123   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
52124   {
52125     try {
52126       (arg1)->Reserve(arg2);
52127     } catch (std::out_of_range& e) {
52128       {
52129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52130       };
52131     } catch (std::exception& e) {
52132       {
52133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52134       };
52135     } catch (Dali::DaliException e) {
52136       {
52137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52138       };
52139     } catch (...) {
52140       {
52141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52142       };
52143     }
52144   }
52145
52146 }
52147
52148
52149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
52150   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52151   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
52152
52153   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52154   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
52155   {
52156     try {
52157       (arg1)->Resize(arg2);
52158     } catch (std::out_of_range& e) {
52159       {
52160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52161       };
52162     } catch (std::exception& e) {
52163       {
52164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52165       };
52166     } catch (Dali::DaliException e) {
52167       {
52168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52169       };
52170     } catch (...) {
52171       {
52172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52173       };
52174     }
52175   }
52176
52177 }
52178
52179
52180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
52181   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52182   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
52183   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
52184
52185   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52186   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
52187   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
52188   if (!arg3) {
52189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
52190     return ;
52191   }
52192   {
52193     try {
52194       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
52195     } catch (std::out_of_range& e) {
52196       {
52197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52198       };
52199     } catch (std::exception& e) {
52200       {
52201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52202       };
52203     } catch (Dali::DaliException e) {
52204       {
52205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52206       };
52207     } catch (...) {
52208       {
52209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52210       };
52211     }
52212   }
52213
52214 }
52215
52216
52217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
52218   void * jresult ;
52219   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52220   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
52221   Dali::Vector< Dali::Uint16Pair >::Iterator result;
52222
52223   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52224   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
52225   {
52226     try {
52227       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
52228     } catch (std::out_of_range& e) {
52229       {
52230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52231       };
52232     } catch (std::exception& e) {
52233       {
52234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52235       };
52236     } catch (Dali::DaliException e) {
52237       {
52238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52239       };
52240     } catch (...) {
52241       {
52242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52243       };
52244     }
52245   }
52246
52247   jresult = (void *)result;
52248   return jresult;
52249 }
52250
52251
52252 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
52253   void * jresult ;
52254   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52255   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
52256   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
52257   Dali::Vector< Dali::Uint16Pair >::Iterator result;
52258
52259   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52260   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
52261   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
52262   {
52263     try {
52264       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
52265     } catch (std::out_of_range& e) {
52266       {
52267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52268       };
52269     } catch (std::exception& e) {
52270       {
52271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52272       };
52273     } catch (Dali::DaliException e) {
52274       {
52275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52276       };
52277     } catch (...) {
52278       {
52279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52280       };
52281     }
52282   }
52283
52284   jresult = (void *)result;
52285   return jresult;
52286 }
52287
52288
52289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
52290   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52291   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
52292
52293   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52294   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
52295   {
52296     try {
52297       (arg1)->Remove(arg2);
52298     } catch (std::out_of_range& e) {
52299       {
52300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52301       };
52302     } catch (std::exception& e) {
52303       {
52304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52305       };
52306     } catch (Dali::DaliException e) {
52307       {
52308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52309       };
52310     } catch (...) {
52311       {
52312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52313       };
52314     }
52315   }
52316
52317 }
52318
52319
52320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
52321   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52322   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
52323
52324   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52325   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
52326   if (!arg2) {
52327     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
52328     return ;
52329   }
52330   {
52331     try {
52332       (arg1)->Swap(*arg2);
52333     } catch (std::out_of_range& e) {
52334       {
52335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52336       };
52337     } catch (std::exception& e) {
52338       {
52339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52340       };
52341     } catch (Dali::DaliException e) {
52342       {
52343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52344       };
52345     } catch (...) {
52346       {
52347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52348       };
52349     }
52350   }
52351
52352 }
52353
52354
52355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
52356   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52357
52358   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52359   {
52360     try {
52361       (arg1)->Clear();
52362     } catch (std::out_of_range& e) {
52363       {
52364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52365       };
52366     } catch (std::exception& e) {
52367       {
52368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52369       };
52370     } catch (Dali::DaliException e) {
52371       {
52372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52373       };
52374     } catch (...) {
52375       {
52376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52377       };
52378     }
52379   }
52380
52381 }
52382
52383
52384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
52385   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
52386
52387   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
52388   {
52389     try {
52390       (arg1)->Release();
52391     } catch (std::out_of_range& e) {
52392       {
52393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52394       };
52395     } catch (std::exception& e) {
52396       {
52397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52398       };
52399     } catch (Dali::DaliException e) {
52400       {
52401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52402       };
52403     } catch (...) {
52404       {
52405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52406       };
52407     }
52408   }
52409
52410 }
52411
52412
52413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
52414   void * jresult ;
52415   Dali::Signal< void () > *result = 0 ;
52416
52417   {
52418     try {
52419       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
52420     } catch (std::out_of_range& e) {
52421       {
52422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52423       };
52424     } catch (std::exception& e) {
52425       {
52426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52427       };
52428     } catch (Dali::DaliException e) {
52429       {
52430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52431       };
52432     } catch (...) {
52433       {
52434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52435       };
52436     }
52437   }
52438
52439   jresult = (void *)result;
52440   return jresult;
52441 }
52442
52443
52444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
52445   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52446
52447   arg1 = (Dali::Signal< void () > *)jarg1;
52448   {
52449     try {
52450       delete arg1;
52451     } catch (std::out_of_range& e) {
52452       {
52453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52454       };
52455     } catch (std::exception& e) {
52456       {
52457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52458       };
52459     } catch (Dali::DaliException e) {
52460       {
52461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52462       };
52463     } catch (...) {
52464       {
52465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52466       };
52467     }
52468   }
52469
52470 }
52471
52472
52473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
52474   unsigned int jresult ;
52475   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52476   bool result;
52477
52478   arg1 = (Dali::Signal< void () > *)jarg1;
52479   {
52480     try {
52481       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
52482     } catch (std::out_of_range& e) {
52483       {
52484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52485       };
52486     } catch (std::exception& e) {
52487       {
52488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52489       };
52490     } catch (Dali::DaliException e) {
52491       {
52492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52493       };
52494     } catch (...) {
52495       {
52496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52497       };
52498     }
52499   }
52500
52501   jresult = result;
52502   return jresult;
52503 }
52504
52505
52506 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
52507   unsigned long jresult ;
52508   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52509   std::size_t result;
52510
52511   arg1 = (Dali::Signal< void () > *)jarg1;
52512   {
52513     try {
52514       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
52515     } catch (std::out_of_range& e) {
52516       {
52517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52518       };
52519     } catch (std::exception& e) {
52520       {
52521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52522       };
52523     } catch (Dali::DaliException e) {
52524       {
52525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52526       };
52527     } catch (...) {
52528       {
52529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52530       };
52531     }
52532   }
52533
52534   jresult = (unsigned long)result;
52535   return jresult;
52536 }
52537
52538
52539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
52540   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52541   void (*arg2)() = (void (*)()) 0 ;
52542
52543   arg1 = (Dali::Signal< void () > *)jarg1;
52544   arg2 = (void (*)())jarg2;
52545   {
52546     try {
52547       (arg1)->Connect(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 (Dali::DaliException e) {
52557       {
52558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52559       };
52560     } catch (...) {
52561       {
52562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52563       };
52564     }
52565   }
52566
52567 }
52568
52569
52570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
52571   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52572   void (*arg2)() = (void (*)()) 0 ;
52573
52574   arg1 = (Dali::Signal< void () > *)jarg1;
52575   arg2 = (void (*)())jarg2;
52576   {
52577     try {
52578       (arg1)->Disconnect(arg2);
52579     } catch (std::out_of_range& e) {
52580       {
52581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52582       };
52583     } catch (std::exception& e) {
52584       {
52585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52586       };
52587     } catch (Dali::DaliException e) {
52588       {
52589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52590       };
52591     } catch (...) {
52592       {
52593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52594       };
52595     }
52596   }
52597
52598 }
52599
52600
52601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
52602   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52603   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
52604   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
52605
52606   arg1 = (Dali::Signal< void () > *)jarg1;
52607   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
52608   arg3 = (Dali::FunctorDelegate *)jarg3;
52609   {
52610     try {
52611       (arg1)->Connect(arg2,arg3);
52612     } catch (std::out_of_range& e) {
52613       {
52614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52615       };
52616     } catch (std::exception& e) {
52617       {
52618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52619       };
52620     } catch (Dali::DaliException e) {
52621       {
52622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52623       };
52624     } catch (...) {
52625       {
52626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52627       };
52628     }
52629   }
52630
52631 }
52632
52633
52634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
52635   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
52636
52637   arg1 = (Dali::Signal< void () > *)jarg1;
52638   {
52639     try {
52640       (arg1)->Emit();
52641     } catch (std::out_of_range& e) {
52642       {
52643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52644       };
52645     } catch (std::exception& e) {
52646       {
52647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52648       };
52649     } catch (Dali::DaliException e) {
52650       {
52651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52652       };
52653     } catch (...) {
52654       {
52655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52656       };
52657     }
52658   }
52659
52660 }
52661
52662
52663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
52664   unsigned int jresult ;
52665   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52666   bool result;
52667
52668   arg1 = (Dali::Signal< void (float) > *)jarg1;
52669   {
52670     try {
52671       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
52672     } catch (std::out_of_range& e) {
52673       {
52674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52675       };
52676     } catch (std::exception& e) {
52677       {
52678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52679       };
52680     } catch (Dali::DaliException e) {
52681       {
52682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52683       };
52684     } catch (...) {
52685       {
52686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52687       };
52688     }
52689   }
52690
52691   jresult = result;
52692   return jresult;
52693 }
52694
52695
52696 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
52697   unsigned long jresult ;
52698   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52699   std::size_t result;
52700
52701   arg1 = (Dali::Signal< void (float) > *)jarg1;
52702   {
52703     try {
52704       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
52705     } catch (std::out_of_range& e) {
52706       {
52707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52708       };
52709     } catch (std::exception& e) {
52710       {
52711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52712       };
52713     } catch (Dali::DaliException e) {
52714       {
52715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52716       };
52717     } catch (...) {
52718       {
52719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52720       };
52721     }
52722   }
52723
52724   jresult = (unsigned long)result;
52725   return jresult;
52726 }
52727
52728
52729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
52730   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52731   void (*arg2)(float) = (void (*)(float)) 0 ;
52732
52733   arg1 = (Dali::Signal< void (float) > *)jarg1;
52734   arg2 = (void (*)(float))jarg2;
52735   {
52736     try {
52737       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
52738     } catch (std::out_of_range& e) {
52739       {
52740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52741       };
52742     } catch (std::exception& e) {
52743       {
52744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52745       };
52746     } catch (Dali::DaliException e) {
52747       {
52748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52749       };
52750     } catch (...) {
52751       {
52752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52753       };
52754     }
52755   }
52756
52757 }
52758
52759
52760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
52761   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52762   void (*arg2)(float) = (void (*)(float)) 0 ;
52763
52764   arg1 = (Dali::Signal< void (float) > *)jarg1;
52765   arg2 = (void (*)(float))jarg2;
52766   {
52767     try {
52768       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
52769     } catch (std::out_of_range& e) {
52770       {
52771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52772       };
52773     } catch (std::exception& e) {
52774       {
52775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52776       };
52777     } catch (Dali::DaliException e) {
52778       {
52779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52780       };
52781     } catch (...) {
52782       {
52783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52784       };
52785     }
52786   }
52787
52788 }
52789
52790
52791 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
52792   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52793   float arg2 ;
52794
52795   arg1 = (Dali::Signal< void (float) > *)jarg1;
52796   arg2 = (float)jarg2;
52797   {
52798     try {
52799       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
52800     } catch (std::out_of_range& e) {
52801       {
52802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52803       };
52804     } catch (std::exception& e) {
52805       {
52806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52807       };
52808     } catch (Dali::DaliException e) {
52809       {
52810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52811       };
52812     } catch (...) {
52813       {
52814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52815       };
52816     }
52817   }
52818
52819 }
52820
52821
52822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
52823   void * jresult ;
52824   Dali::Signal< void (float) > *result = 0 ;
52825
52826   {
52827     try {
52828       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
52829     } catch (std::out_of_range& e) {
52830       {
52831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52832       };
52833     } catch (std::exception& e) {
52834       {
52835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52836       };
52837     } catch (Dali::DaliException e) {
52838       {
52839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52840       };
52841     } catch (...) {
52842       {
52843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52844       };
52845     }
52846   }
52847
52848   jresult = (void *)result;
52849   return jresult;
52850 }
52851
52852
52853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
52854   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
52855
52856   arg1 = (Dali::Signal< void (float) > *)jarg1;
52857   {
52858     try {
52859       delete arg1;
52860     } catch (std::out_of_range& e) {
52861       {
52862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52863       };
52864     } catch (std::exception& e) {
52865       {
52866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52867       };
52868     } catch (Dali::DaliException e) {
52869       {
52870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52871       };
52872     } catch (...) {
52873       {
52874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52875       };
52876     }
52877   }
52878
52879 }
52880
52881
52882 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
52883   unsigned int jresult ;
52884   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52885   bool result;
52886
52887   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52888   {
52889     try {
52890       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
52891     } catch (std::out_of_range& e) {
52892       {
52893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52894       };
52895     } catch (std::exception& e) {
52896       {
52897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52898       };
52899     } catch (Dali::DaliException e) {
52900       {
52901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52902       };
52903     } catch (...) {
52904       {
52905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52906       };
52907     }
52908   }
52909
52910   jresult = result;
52911   return jresult;
52912 }
52913
52914
52915 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
52916   unsigned long jresult ;
52917   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52918   std::size_t result;
52919
52920   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52921   {
52922     try {
52923       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
52924     } catch (std::out_of_range& e) {
52925       {
52926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52927       };
52928     } catch (std::exception& e) {
52929       {
52930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52931       };
52932     } catch (Dali::DaliException e) {
52933       {
52934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52935       };
52936     } catch (...) {
52937       {
52938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52939       };
52940     }
52941   }
52942
52943   jresult = (unsigned long)result;
52944   return jresult;
52945 }
52946
52947
52948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
52949   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52950   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
52951
52952   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52953   arg2 = (void (*)(Dali::BaseHandle))jarg2;
52954   {
52955     try {
52956       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
52957     } catch (std::out_of_range& e) {
52958       {
52959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52960       };
52961     } catch (std::exception& e) {
52962       {
52963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52964       };
52965     } catch (Dali::DaliException e) {
52966       {
52967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52968       };
52969     } catch (...) {
52970       {
52971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52972       };
52973     }
52974   }
52975
52976 }
52977
52978
52979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
52980   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
52981   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
52982
52983   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
52984   arg2 = (void (*)(Dali::BaseHandle))jarg2;
52985   {
52986     try {
52987       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
52988     } catch (std::out_of_range& e) {
52989       {
52990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52991       };
52992     } catch (std::exception& e) {
52993       {
52994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52995       };
52996     } catch (Dali::DaliException e) {
52997       {
52998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52999       };
53000     } catch (...) {
53001       {
53002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53003       };
53004     }
53005   }
53006
53007 }
53008
53009
53010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
53011   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53012   Dali::BaseHandle arg2 ;
53013   Dali::BaseHandle *argp2 ;
53014
53015   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53016   argp2 = (Dali::BaseHandle *)jarg2;
53017   if (!argp2) {
53018     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
53019     return ;
53020   }
53021   arg2 = *argp2;
53022   {
53023     try {
53024       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
53025     } catch (std::out_of_range& e) {
53026       {
53027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53028       };
53029     } catch (std::exception& e) {
53030       {
53031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53032       };
53033     } catch (Dali::DaliException e) {
53034       {
53035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53036       };
53037     } catch (...) {
53038       {
53039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53040       };
53041     }
53042   }
53043
53044 }
53045
53046
53047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
53048   void * jresult ;
53049   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
53050
53051   {
53052     try {
53053       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
53054     } catch (std::out_of_range& e) {
53055       {
53056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53057       };
53058     } catch (std::exception& e) {
53059       {
53060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53061       };
53062     } catch (Dali::DaliException e) {
53063       {
53064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53065       };
53066     } catch (...) {
53067       {
53068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53069       };
53070     }
53071   }
53072
53073   jresult = (void *)result;
53074   return jresult;
53075 }
53076
53077
53078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
53079   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
53080
53081   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
53082   {
53083     try {
53084       delete arg1;
53085     } catch (std::out_of_range& e) {
53086       {
53087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53088       };
53089     } catch (std::exception& e) {
53090       {
53091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53092       };
53093     } catch (Dali::DaliException e) {
53094       {
53095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53096       };
53097     } catch (...) {
53098       {
53099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53100       };
53101     }
53102   }
53103
53104 }
53105
53106
53107 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
53108   unsigned int jresult ;
53109   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
53110   bool result;
53111
53112   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
53113   {
53114     try {
53115       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
53116     } catch (std::out_of_range& e) {
53117       {
53118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53119       };
53120     } catch (std::exception& e) {
53121       {
53122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53123       };
53124     } catch (Dali::DaliException e) {
53125       {
53126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53127       };
53128     } catch (...) {
53129       {
53130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53131       };
53132     }
53133   }
53134
53135   jresult = result;
53136   return jresult;
53137 }
53138
53139
53140 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
53141   unsigned long jresult ;
53142   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
53143   std::size_t result;
53144
53145   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
53146   {
53147     try {
53148       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
53149     } catch (std::out_of_range& e) {
53150       {
53151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53152       };
53153     } catch (std::exception& e) {
53154       {
53155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53156       };
53157     } catch (Dali::DaliException e) {
53158       {
53159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53160       };
53161     } catch (...) {
53162       {
53163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53164       };
53165     }
53166   }
53167
53168   jresult = (unsigned long)result;
53169   return jresult;
53170 }
53171
53172
53173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
53174   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
53175   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
53176
53177   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
53178   arg2 = (void (*)(Dali::RefObject const *))jarg2;
53179   {
53180     try {
53181       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
53182     } catch (std::out_of_range& e) {
53183       {
53184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53185       };
53186     } catch (std::exception& e) {
53187       {
53188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53189       };
53190     } catch (Dali::DaliException e) {
53191       {
53192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53193       };
53194     } catch (...) {
53195       {
53196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53197       };
53198     }
53199   }
53200
53201 }
53202
53203
53204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
53205   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
53206   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
53207
53208   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
53209   arg2 = (void (*)(Dali::RefObject const *))jarg2;
53210   {
53211     try {
53212       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
53213     } catch (std::out_of_range& e) {
53214       {
53215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53216       };
53217     } catch (std::exception& e) {
53218       {
53219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53220       };
53221     } catch (Dali::DaliException e) {
53222       {
53223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53224       };
53225     } catch (...) {
53226       {
53227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53228       };
53229     }
53230   }
53231
53232 }
53233
53234
53235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
53236   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
53237   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
53238
53239   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
53240   arg2 = (Dali::RefObject *)jarg2;
53241   {
53242     try {
53243       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
53244     } catch (std::out_of_range& e) {
53245       {
53246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53247       };
53248     } catch (std::exception& e) {
53249       {
53250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53251       };
53252     } catch (Dali::DaliException e) {
53253       {
53254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53255       };
53256     } catch (...) {
53257       {
53258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53259       };
53260     }
53261   }
53262
53263 }
53264
53265
53266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
53267   void * jresult ;
53268   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
53269
53270   {
53271     try {
53272       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
53273     } catch (std::out_of_range& e) {
53274       {
53275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53276       };
53277     } catch (std::exception& e) {
53278       {
53279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53280       };
53281     } catch (Dali::DaliException e) {
53282       {
53283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53284       };
53285     } catch (...) {
53286       {
53287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53288       };
53289     }
53290   }
53291
53292   jresult = (void *)result;
53293   return jresult;
53294 }
53295
53296
53297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
53298   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
53299
53300   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
53301   {
53302     try {
53303       delete arg1;
53304     } catch (std::out_of_range& e) {
53305       {
53306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53307       };
53308     } catch (std::exception& e) {
53309       {
53310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53311       };
53312     } catch (Dali::DaliException e) {
53313       {
53314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53315       };
53316     } catch (...) {
53317       {
53318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53319       };
53320     }
53321   }
53322
53323 }
53324
53325
53326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
53327   unsigned int jresult ;
53328   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53329   bool result;
53330
53331   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53332   {
53333     try {
53334       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
53335     } catch (std::out_of_range& e) {
53336       {
53337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53338       };
53339     } catch (std::exception& e) {
53340       {
53341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53342       };
53343     } catch (Dali::DaliException e) {
53344       {
53345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53346       };
53347     } catch (...) {
53348       {
53349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53350       };
53351     }
53352   }
53353
53354   jresult = result;
53355   return jresult;
53356 }
53357
53358
53359 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
53360   unsigned long jresult ;
53361   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53362   std::size_t result;
53363
53364   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53365   {
53366     try {
53367       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
53368     } catch (std::out_of_range& e) {
53369       {
53370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53371       };
53372     } catch (std::exception& e) {
53373       {
53374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53375       };
53376     } catch (Dali::DaliException e) {
53377       {
53378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53379       };
53380     } catch (...) {
53381       {
53382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53383       };
53384     }
53385   }
53386
53387   jresult = (unsigned long)result;
53388   return jresult;
53389 }
53390
53391
53392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
53393   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53394   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
53395
53396   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53397   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
53398   {
53399     try {
53400       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
53401     } catch (std::out_of_range& e) {
53402       {
53403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53404       };
53405     } catch (std::exception& e) {
53406       {
53407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53408       };
53409     } catch (Dali::DaliException e) {
53410       {
53411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53412       };
53413     } catch (...) {
53414       {
53415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53416       };
53417     }
53418   }
53419
53420 }
53421
53422
53423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
53424   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53425   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
53426
53427   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53428   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
53429   {
53430     try {
53431       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
53432     } catch (std::out_of_range& e) {
53433       {
53434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53435       };
53436     } catch (std::exception& e) {
53437       {
53438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53439       };
53440     } catch (Dali::DaliException e) {
53441       {
53442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53443       };
53444     } catch (...) {
53445       {
53446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53447       };
53448     }
53449   }
53450
53451 }
53452
53453
53454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
53455   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53456   Dali::PropertyNotification *arg2 = 0 ;
53457
53458   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53459   arg2 = (Dali::PropertyNotification *)jarg2;
53460   if (!arg2) {
53461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
53462     return ;
53463   }
53464   {
53465     try {
53466       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
53467     } catch (std::out_of_range& e) {
53468       {
53469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53470       };
53471     } catch (std::exception& e) {
53472       {
53473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53474       };
53475     } catch (Dali::DaliException e) {
53476       {
53477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53478       };
53479     } catch (...) {
53480       {
53481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53482       };
53483     }
53484   }
53485
53486 }
53487
53488
53489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
53490   void * jresult ;
53491   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
53492
53493   {
53494     try {
53495       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
53496     } catch (std::out_of_range& e) {
53497       {
53498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53499       };
53500     } catch (std::exception& e) {
53501       {
53502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53503       };
53504     } catch (Dali::DaliException e) {
53505       {
53506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53507       };
53508     } catch (...) {
53509       {
53510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53511       };
53512     }
53513   }
53514
53515   jresult = (void *)result;
53516   return jresult;
53517 }
53518
53519
53520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
53521   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
53522
53523   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
53524   {
53525     try {
53526       delete arg1;
53527     } catch (std::out_of_range& e) {
53528       {
53529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53530       };
53531     } catch (std::exception& e) {
53532       {
53533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53534       };
53535     } catch (Dali::DaliException e) {
53536       {
53537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53538       };
53539     } catch (...) {
53540       {
53541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53542       };
53543     }
53544   }
53545
53546 }
53547
53548
53549 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ImageSignal_Empty(void * jarg1) {
53550   unsigned int jresult ;
53551   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
53552   bool result;
53553
53554   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
53555   {
53556     try {
53557       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Empty((Dali::Signal< void (Dali::Image) > const *)arg1);
53558     } catch (std::out_of_range& e) {
53559       {
53560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53561       };
53562     } catch (std::exception& e) {
53563       {
53564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53565       };
53566     } catch (Dali::DaliException e) {
53567       {
53568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53569       };
53570     } catch (...) {
53571       {
53572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53573       };
53574     }
53575   }
53576
53577   jresult = result;
53578   return jresult;
53579 }
53580
53581
53582 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ImageSignal_GetConnectionCount(void * jarg1) {
53583   unsigned long jresult ;
53584   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
53585   std::size_t result;
53586
53587   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
53588   {
53589     try {
53590       result = Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Image) > const *)arg1);
53591     } catch (std::out_of_range& e) {
53592       {
53593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53594       };
53595     } catch (std::exception& e) {
53596       {
53597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53598       };
53599     } catch (Dali::DaliException e) {
53600       {
53601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53602       };
53603     } catch (...) {
53604       {
53605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53606       };
53607     }
53608   }
53609
53610   jresult = (unsigned long)result;
53611   return jresult;
53612 }
53613
53614
53615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Connect(void * jarg1, void * jarg2) {
53616   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
53617   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
53618
53619   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
53620   arg2 = (void (*)(Dali::Image))jarg2;
53621   {
53622     try {
53623       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Connect(arg1,arg2);
53624     } catch (std::out_of_range& e) {
53625       {
53626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53627       };
53628     } catch (std::exception& e) {
53629       {
53630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53631       };
53632     } catch (Dali::DaliException e) {
53633       {
53634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53635       };
53636     } catch (...) {
53637       {
53638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53639       };
53640     }
53641   }
53642
53643 }
53644
53645
53646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Disconnect(void * jarg1, void * jarg2) {
53647   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
53648   void (*arg2)(Dali::Image) = (void (*)(Dali::Image)) 0 ;
53649
53650   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
53651   arg2 = (void (*)(Dali::Image))jarg2;
53652   {
53653     try {
53654       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Disconnect(arg1,arg2);
53655     } catch (std::out_of_range& e) {
53656       {
53657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53658       };
53659     } catch (std::exception& e) {
53660       {
53661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53662       };
53663     } catch (Dali::DaliException e) {
53664       {
53665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53666       };
53667     } catch (...) {
53668       {
53669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53670       };
53671     }
53672   }
53673
53674 }
53675
53676
53677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageSignal_Emit(void * jarg1, void * jarg2) {
53678   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
53679   Dali::Image arg2 ;
53680   Dali::Image *argp2 ;
53681
53682   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
53683   argp2 = (Dali::Image *)jarg2;
53684   if (!argp2) {
53685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
53686     return ;
53687   }
53688   arg2 = *argp2;
53689   {
53690     try {
53691       Dali_Signal_Sl_void_Sp_Dali_Image_SP__Sg__Emit(arg1,arg2);
53692     } catch (std::out_of_range& e) {
53693       {
53694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53695       };
53696     } catch (std::exception& e) {
53697       {
53698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53699       };
53700     } catch (Dali::DaliException e) {
53701       {
53702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53703       };
53704     } catch (...) {
53705       {
53706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53707       };
53708     }
53709   }
53710
53711 }
53712
53713
53714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageSignal() {
53715   void * jresult ;
53716   Dali::Signal< void (Dali::Image) > *result = 0 ;
53717
53718   {
53719     try {
53720       result = (Dali::Signal< void (Dali::Image) > *)new Dali::Signal< void (Dali::Image) >();
53721     } catch (std::out_of_range& e) {
53722       {
53723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53724       };
53725     } catch (std::exception& e) {
53726       {
53727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53728       };
53729     } catch (Dali::DaliException e) {
53730       {
53731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53732       };
53733     } catch (...) {
53734       {
53735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53736       };
53737     }
53738   }
53739
53740   jresult = (void *)result;
53741   return jresult;
53742 }
53743
53744
53745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageSignal(void * jarg1) {
53746   Dali::Signal< void (Dali::Image) > *arg1 = (Dali::Signal< void (Dali::Image) > *) 0 ;
53747
53748   arg1 = (Dali::Signal< void (Dali::Image) > *)jarg1;
53749   {
53750     try {
53751       delete arg1;
53752     } catch (std::out_of_range& e) {
53753       {
53754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53755       };
53756     } catch (std::exception& e) {
53757       {
53758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53759       };
53760     } catch (Dali::DaliException e) {
53761       {
53762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53763       };
53764     } catch (...) {
53765       {
53766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53767       };
53768     }
53769   }
53770
53771 }
53772
53773
53774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
53775   void * jresult ;
53776   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
53777
53778   {
53779     try {
53780       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
53781     } catch (std::out_of_range& e) {
53782       {
53783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53784       };
53785     } catch (std::exception& e) {
53786       {
53787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53788       };
53789     } catch (Dali::DaliException e) {
53790       {
53791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53792       };
53793     } catch (...) {
53794       {
53795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53796       };
53797     }
53798   }
53799
53800   jresult = (void *)result;
53801   return jresult;
53802 }
53803
53804
53805 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
53806   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
53807
53808   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
53809   {
53810     try {
53811       delete arg1;
53812     } catch (std::out_of_range& e) {
53813       {
53814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53815       };
53816     } catch (std::exception& e) {
53817       {
53818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53819       };
53820     } catch (Dali::DaliException e) {
53821       {
53822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53823       };
53824     } catch (...) {
53825       {
53826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53827       };
53828     }
53829   }
53830
53831 }
53832
53833
53834 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
53835   unsigned int jresult ;
53836   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53837   bool result;
53838
53839   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53840   {
53841     try {
53842       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);
53843     } catch (std::out_of_range& e) {
53844       {
53845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53846       };
53847     } catch (std::exception& e) {
53848       {
53849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53850       };
53851     } catch (Dali::DaliException e) {
53852       {
53853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53854       };
53855     } catch (...) {
53856       {
53857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53858       };
53859     }
53860   }
53861
53862   jresult = result;
53863   return jresult;
53864 }
53865
53866
53867 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53868   unsigned long jresult ;
53869   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53870   std::size_t result;
53871
53872   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53873   {
53874     try {
53875       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);
53876     } catch (std::out_of_range& e) {
53877       {
53878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53879       };
53880     } catch (std::exception& e) {
53881       {
53882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53883       };
53884     } catch (Dali::DaliException e) {
53885       {
53886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53887       };
53888     } catch (...) {
53889       {
53890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53891       };
53892     }
53893   }
53894
53895   jresult = (unsigned long)result;
53896   return jresult;
53897 }
53898
53899
53900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53901   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53902   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
53903
53904   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53905   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
53906   {
53907     try {
53908       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53909     } catch (std::out_of_range& e) {
53910       {
53911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53912       };
53913     } catch (std::exception& e) {
53914       {
53915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53916       };
53917     } catch (Dali::DaliException e) {
53918       {
53919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53920       };
53921     } catch (...) {
53922       {
53923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53924       };
53925     }
53926   }
53927
53928 }
53929
53930
53931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53932   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53933   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
53934
53935   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53936   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
53937   {
53938     try {
53939       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53940     } catch (std::out_of_range& e) {
53941       {
53942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53943       };
53944     } catch (std::exception& e) {
53945       {
53946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53947       };
53948     } catch (Dali::DaliException e) {
53949       {
53950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53951       };
53952     } catch (...) {
53953       {
53954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53955       };
53956     }
53957   }
53958
53959 }
53960
53961
53962 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53963   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
53964   Dali::Actor arg2 ;
53965   Dali::LongPressGesture *arg3 = 0 ;
53966   Dali::Actor *argp2 ;
53967
53968   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
53969   argp2 = (Dali::Actor *)jarg2;
53970   if (!argp2) {
53971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53972     return ;
53973   }
53974   arg2 = *argp2;
53975   arg3 = (Dali::LongPressGesture *)jarg3;
53976   if (!arg3) {
53977     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
53978     return ;
53979   }
53980   {
53981     try {
53982       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
53983     } catch (std::out_of_range& e) {
53984       {
53985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53986       };
53987     } catch (std::exception& e) {
53988       {
53989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53990       };
53991     } catch (Dali::DaliException e) {
53992       {
53993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53994       };
53995     } catch (...) {
53996       {
53997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53998       };
53999     }
54000   }
54001
54002 }
54003
54004
54005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
54006   void * jresult ;
54007   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
54008
54009   {
54010     try {
54011       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
54012     } catch (std::out_of_range& e) {
54013       {
54014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54015       };
54016     } catch (std::exception& e) {
54017       {
54018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54019       };
54020     } catch (Dali::DaliException e) {
54021       {
54022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54023       };
54024     } catch (...) {
54025       {
54026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54027       };
54028     }
54029   }
54030
54031   jresult = (void *)result;
54032   return jresult;
54033 }
54034
54035
54036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
54037   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
54038
54039   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
54040   {
54041     try {
54042       delete arg1;
54043     } catch (std::out_of_range& e) {
54044       {
54045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54046       };
54047     } catch (std::exception& e) {
54048       {
54049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54050       };
54051     } catch (Dali::DaliException e) {
54052       {
54053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54054       };
54055     } catch (...) {
54056       {
54057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54058       };
54059     }
54060   }
54061
54062 }
54063
54064
54065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
54066   unsigned int jresult ;
54067   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
54068   bool result;
54069
54070   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
54071   {
54072     try {
54073       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);
54074     } catch (std::out_of_range& e) {
54075       {
54076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54077       };
54078     } catch (std::exception& e) {
54079       {
54080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54081       };
54082     } catch (Dali::DaliException e) {
54083       {
54084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54085       };
54086     } catch (...) {
54087       {
54088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54089       };
54090     }
54091   }
54092
54093   jresult = result;
54094   return jresult;
54095 }
54096
54097
54098 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
54099   unsigned long jresult ;
54100   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
54101   std::size_t result;
54102
54103   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
54104   {
54105     try {
54106       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);
54107     } catch (std::out_of_range& e) {
54108       {
54109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54110       };
54111     } catch (std::exception& e) {
54112       {
54113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54114       };
54115     } catch (Dali::DaliException e) {
54116       {
54117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54118       };
54119     } catch (...) {
54120       {
54121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54122       };
54123     }
54124   }
54125
54126   jresult = (unsigned long)result;
54127   return jresult;
54128 }
54129
54130
54131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
54132   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
54133   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
54134
54135   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
54136   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
54137   {
54138     try {
54139       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54140     } catch (std::out_of_range& e) {
54141       {
54142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54143       };
54144     } catch (std::exception& e) {
54145       {
54146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54147       };
54148     } catch (Dali::DaliException e) {
54149       {
54150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54151       };
54152     } catch (...) {
54153       {
54154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54155       };
54156     }
54157   }
54158
54159 }
54160
54161
54162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
54163   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
54164   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
54165
54166   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
54167   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
54168   {
54169     try {
54170       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54171     } catch (std::out_of_range& e) {
54172       {
54173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54174       };
54175     } catch (std::exception& e) {
54176       {
54177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54178       };
54179     } catch (Dali::DaliException e) {
54180       {
54181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54182       };
54183     } catch (...) {
54184       {
54185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54186       };
54187     }
54188   }
54189
54190 }
54191
54192
54193 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54194   unsigned int jresult ;
54195   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
54196   Dali::Actor arg2 ;
54197   Dali::TouchData *arg3 = 0 ;
54198   Dali::Actor *argp2 ;
54199   bool result;
54200
54201   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
54202   argp2 = (Dali::Actor *)jarg2;
54203   if (!argp2) {
54204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54205     return 0;
54206   }
54207   arg2 = *argp2;
54208   arg3 = (Dali::TouchData *)jarg3;
54209   if (!arg3) {
54210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
54211     return 0;
54212   }
54213   {
54214     try {
54215       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
54216     } catch (std::out_of_range& e) {
54217       {
54218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54219       };
54220     } catch (std::exception& e) {
54221       {
54222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54223       };
54224     } catch (Dali::DaliException e) {
54225       {
54226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54227       };
54228     } catch (...) {
54229       {
54230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54231       };
54232     }
54233   }
54234
54235   jresult = result;
54236   return jresult;
54237 }
54238
54239
54240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
54241   void * jresult ;
54242   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
54243
54244   {
54245     try {
54246       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
54247     } catch (std::out_of_range& e) {
54248       {
54249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54250       };
54251     } catch (std::exception& e) {
54252       {
54253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54254       };
54255     } catch (Dali::DaliException e) {
54256       {
54257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54258       };
54259     } catch (...) {
54260       {
54261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54262       };
54263     }
54264   }
54265
54266   jresult = (void *)result;
54267   return jresult;
54268 }
54269
54270
54271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
54272   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
54273
54274   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
54275   {
54276     try {
54277       delete arg1;
54278     } catch (std::out_of_range& e) {
54279       {
54280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54281       };
54282     } catch (std::exception& e) {
54283       {
54284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54285       };
54286     } catch (Dali::DaliException e) {
54287       {
54288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54289       };
54290     } catch (...) {
54291       {
54292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54293       };
54294     }
54295   }
54296
54297 }
54298
54299
54300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
54301   unsigned int jresult ;
54302   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
54303   bool result;
54304
54305   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
54306   {
54307     try {
54308       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);
54309     } catch (std::out_of_range& e) {
54310       {
54311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54312       };
54313     } catch (std::exception& e) {
54314       {
54315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54316       };
54317     } catch (Dali::DaliException e) {
54318       {
54319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54320       };
54321     } catch (...) {
54322       {
54323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54324       };
54325     }
54326   }
54327
54328   jresult = result;
54329   return jresult;
54330 }
54331
54332
54333 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
54334   unsigned long jresult ;
54335   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
54336   std::size_t result;
54337
54338   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
54339   {
54340     try {
54341       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);
54342     } catch (std::out_of_range& e) {
54343       {
54344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54345       };
54346     } catch (std::exception& e) {
54347       {
54348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54349       };
54350     } catch (Dali::DaliException e) {
54351       {
54352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54353       };
54354     } catch (...) {
54355       {
54356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54357       };
54358     }
54359   }
54360
54361   jresult = (unsigned long)result;
54362   return jresult;
54363 }
54364
54365
54366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
54367   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
54368   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
54369
54370   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
54371   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
54372   {
54373     try {
54374       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54375     } catch (std::out_of_range& e) {
54376       {
54377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54378       };
54379     } catch (std::exception& e) {
54380       {
54381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54382       };
54383     } catch (Dali::DaliException e) {
54384       {
54385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54386       };
54387     } catch (...) {
54388       {
54389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54390       };
54391     }
54392   }
54393
54394 }
54395
54396
54397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
54398   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
54399   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
54400
54401   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
54402   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
54403   {
54404     try {
54405       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54406     } catch (std::out_of_range& e) {
54407       {
54408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54409       };
54410     } catch (std::exception& e) {
54411       {
54412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54413       };
54414     } catch (Dali::DaliException e) {
54415       {
54416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54417       };
54418     } catch (...) {
54419       {
54420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54421       };
54422     }
54423   }
54424
54425 }
54426
54427
54428 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54429   unsigned int jresult ;
54430   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
54431   Dali::Actor arg2 ;
54432   Dali::HoverEvent *arg3 = 0 ;
54433   Dali::Actor *argp2 ;
54434   bool result;
54435
54436   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
54437   argp2 = (Dali::Actor *)jarg2;
54438   if (!argp2) {
54439     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54440     return 0;
54441   }
54442   arg2 = *argp2;
54443   arg3 = (Dali::HoverEvent *)jarg3;
54444   if (!arg3) {
54445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
54446     return 0;
54447   }
54448   {
54449     try {
54450       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
54451     } catch (std::out_of_range& e) {
54452       {
54453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54454       };
54455     } catch (std::exception& e) {
54456       {
54457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54458       };
54459     } catch (Dali::DaliException e) {
54460       {
54461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54462       };
54463     } catch (...) {
54464       {
54465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54466       };
54467     }
54468   }
54469
54470   jresult = result;
54471   return jresult;
54472 }
54473
54474
54475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
54476   void * jresult ;
54477   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
54478
54479   {
54480     try {
54481       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
54482     } catch (std::out_of_range& e) {
54483       {
54484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54485       };
54486     } catch (std::exception& e) {
54487       {
54488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54489       };
54490     } catch (Dali::DaliException e) {
54491       {
54492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54493       };
54494     } catch (...) {
54495       {
54496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54497       };
54498     }
54499   }
54500
54501   jresult = (void *)result;
54502   return jresult;
54503 }
54504
54505
54506 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
54507   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
54508
54509   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
54510   {
54511     try {
54512       delete arg1;
54513     } catch (std::out_of_range& e) {
54514       {
54515         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54516       };
54517     } catch (std::exception& e) {
54518       {
54519         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54520       };
54521     } catch (Dali::DaliException e) {
54522       {
54523         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54524       };
54525     } catch (...) {
54526       {
54527         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54528       };
54529     }
54530   }
54531
54532 }
54533
54534
54535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
54536   unsigned int jresult ;
54537   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54538   bool result;
54539
54540   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54541   {
54542     try {
54543       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);
54544     } catch (std::out_of_range& e) {
54545       {
54546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54547       };
54548     } catch (std::exception& e) {
54549       {
54550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54551       };
54552     } catch (Dali::DaliException e) {
54553       {
54554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54555       };
54556     } catch (...) {
54557       {
54558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54559       };
54560     }
54561   }
54562
54563   jresult = result;
54564   return jresult;
54565 }
54566
54567
54568 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
54569   unsigned long jresult ;
54570   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54571   std::size_t result;
54572
54573   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54574   {
54575     try {
54576       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);
54577     } catch (std::out_of_range& e) {
54578       {
54579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54580       };
54581     } catch (std::exception& e) {
54582       {
54583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54584       };
54585     } catch (Dali::DaliException e) {
54586       {
54587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54588       };
54589     } catch (...) {
54590       {
54591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54592       };
54593     }
54594   }
54595
54596   jresult = (unsigned long)result;
54597   return jresult;
54598 }
54599
54600
54601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
54602   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54603   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
54604
54605   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54606   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
54607   {
54608     try {
54609       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54610     } catch (std::out_of_range& e) {
54611       {
54612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54613       };
54614     } catch (std::exception& e) {
54615       {
54616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54617       };
54618     } catch (Dali::DaliException e) {
54619       {
54620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54621       };
54622     } catch (...) {
54623       {
54624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54625       };
54626     }
54627   }
54628
54629 }
54630
54631
54632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
54633   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54634   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
54635
54636   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54637   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
54638   {
54639     try {
54640       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54641     } catch (std::out_of_range& e) {
54642       {
54643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54644       };
54645     } catch (std::exception& e) {
54646       {
54647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54648       };
54649     } catch (Dali::DaliException e) {
54650       {
54651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54652       };
54653     } catch (...) {
54654       {
54655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54656       };
54657     }
54658   }
54659
54660 }
54661
54662
54663 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54664   unsigned int jresult ;
54665   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54666   Dali::Actor arg2 ;
54667   Dali::WheelEvent *arg3 = 0 ;
54668   Dali::Actor *argp2 ;
54669   bool result;
54670
54671   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54672   argp2 = (Dali::Actor *)jarg2;
54673   if (!argp2) {
54674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54675     return 0;
54676   }
54677   arg2 = *argp2;
54678   arg3 = (Dali::WheelEvent *)jarg3;
54679   if (!arg3) {
54680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
54681     return 0;
54682   }
54683   {
54684     try {
54685       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
54686     } catch (std::out_of_range& e) {
54687       {
54688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54689       };
54690     } catch (std::exception& e) {
54691       {
54692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54693       };
54694     } catch (Dali::DaliException e) {
54695       {
54696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54697       };
54698     } catch (...) {
54699       {
54700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54701       };
54702     }
54703   }
54704
54705   jresult = result;
54706   return jresult;
54707 }
54708
54709
54710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
54711   void * jresult ;
54712   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
54713
54714   {
54715     try {
54716       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
54717     } catch (std::out_of_range& e) {
54718       {
54719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54720       };
54721     } catch (std::exception& e) {
54722       {
54723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54724       };
54725     } catch (Dali::DaliException e) {
54726       {
54727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54728       };
54729     } catch (...) {
54730       {
54731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54732       };
54733     }
54734   }
54735
54736   jresult = (void *)result;
54737   return jresult;
54738 }
54739
54740
54741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
54742   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
54743
54744   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
54745   {
54746     try {
54747       delete arg1;
54748     } catch (std::out_of_range& e) {
54749       {
54750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54751       };
54752     } catch (std::exception& e) {
54753       {
54754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54755       };
54756     } catch (Dali::DaliException e) {
54757       {
54758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54759       };
54760     } catch (...) {
54761       {
54762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54763       };
54764     }
54765   }
54766
54767 }
54768
54769
54770 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
54771   unsigned int jresult ;
54772   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54773   bool result;
54774
54775   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54776   {
54777     try {
54778       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
54779     } catch (std::out_of_range& e) {
54780       {
54781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54782       };
54783     } catch (std::exception& e) {
54784       {
54785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54786       };
54787     } catch (Dali::DaliException e) {
54788       {
54789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54790       };
54791     } catch (...) {
54792       {
54793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54794       };
54795     }
54796   }
54797
54798   jresult = result;
54799   return jresult;
54800 }
54801
54802
54803 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
54804   unsigned long jresult ;
54805   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54806   std::size_t result;
54807
54808   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54809   {
54810     try {
54811       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
54812     } catch (std::out_of_range& e) {
54813       {
54814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54815       };
54816     } catch (std::exception& e) {
54817       {
54818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54819       };
54820     } catch (Dali::DaliException e) {
54821       {
54822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54823       };
54824     } catch (...) {
54825       {
54826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54827       };
54828     }
54829   }
54830
54831   jresult = (unsigned long)result;
54832   return jresult;
54833 }
54834
54835
54836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
54837   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54838   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
54839
54840   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54841   arg2 = (void (*)(Dali::Actor))jarg2;
54842   {
54843     try {
54844       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
54845     } catch (std::out_of_range& e) {
54846       {
54847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54848       };
54849     } catch (std::exception& e) {
54850       {
54851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54852       };
54853     } catch (Dali::DaliException e) {
54854       {
54855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54856       };
54857     } catch (...) {
54858       {
54859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54860       };
54861     }
54862   }
54863
54864 }
54865
54866
54867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
54868   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54869   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
54870
54871   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54872   arg2 = (void (*)(Dali::Actor))jarg2;
54873   {
54874     try {
54875       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
54876     } catch (std::out_of_range& e) {
54877       {
54878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54879       };
54880     } catch (std::exception& e) {
54881       {
54882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54883       };
54884     } catch (Dali::DaliException e) {
54885       {
54886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54887       };
54888     } catch (...) {
54889       {
54890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54891       };
54892     }
54893   }
54894
54895 }
54896
54897
54898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
54899   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54900   Dali::Actor arg2 ;
54901   Dali::Actor *argp2 ;
54902
54903   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54904   argp2 = (Dali::Actor *)jarg2;
54905   if (!argp2) {
54906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54907     return ;
54908   }
54909   arg2 = *argp2;
54910   {
54911     try {
54912       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
54913     } catch (std::out_of_range& e) {
54914       {
54915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54916       };
54917     } catch (std::exception& e) {
54918       {
54919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54920       };
54921     } catch (Dali::DaliException e) {
54922       {
54923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54924       };
54925     } catch (...) {
54926       {
54927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54928       };
54929     }
54930   }
54931
54932 }
54933
54934
54935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
54936   void * jresult ;
54937   Dali::Signal< void (Dali::Actor) > *result = 0 ;
54938
54939   {
54940     try {
54941       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
54942     } catch (std::out_of_range& e) {
54943       {
54944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54945       };
54946     } catch (std::exception& e) {
54947       {
54948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54949       };
54950     } catch (Dali::DaliException e) {
54951       {
54952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54953       };
54954     } catch (...) {
54955       {
54956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54957       };
54958     }
54959   }
54960
54961   jresult = (void *)result;
54962   return jresult;
54963 }
54964
54965
54966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
54967   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
54968
54969   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
54970   {
54971     try {
54972       delete arg1;
54973     } catch (std::out_of_range& e) {
54974       {
54975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54976       };
54977     } catch (std::exception& e) {
54978       {
54979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54980       };
54981     } catch (Dali::DaliException e) {
54982       {
54983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54984       };
54985     } catch (...) {
54986       {
54987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54988       };
54989     }
54990   }
54991
54992 }
54993
54994
54995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
54996   unsigned int jresult ;
54997   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
54998   bool result;
54999
55000   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
55001   {
55002     try {
55003       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
55004     } catch (std::out_of_range& e) {
55005       {
55006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55007       };
55008     } catch (std::exception& e) {
55009       {
55010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55011       };
55012     } catch (Dali::DaliException e) {
55013       {
55014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55015       };
55016     } catch (...) {
55017       {
55018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55019       };
55020     }
55021   }
55022
55023   jresult = result;
55024   return jresult;
55025 }
55026
55027
55028 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
55029   unsigned long jresult ;
55030   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
55031   std::size_t result;
55032
55033   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
55034   {
55035     try {
55036       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
55037     } catch (std::out_of_range& e) {
55038       {
55039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55040       };
55041     } catch (std::exception& e) {
55042       {
55043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55044       };
55045     } catch (Dali::DaliException e) {
55046       {
55047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55048       };
55049     } catch (...) {
55050       {
55051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55052       };
55053     }
55054   }
55055
55056   jresult = (unsigned long)result;
55057   return jresult;
55058 }
55059
55060
55061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
55062   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
55063   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
55064
55065   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
55066   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
55067   {
55068     try {
55069       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55070     } catch (std::out_of_range& e) {
55071       {
55072         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55073       };
55074     } catch (std::exception& e) {
55075       {
55076         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55077       };
55078     } catch (Dali::DaliException e) {
55079       {
55080         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55081       };
55082     } catch (...) {
55083       {
55084         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55085       };
55086     }
55087   }
55088
55089 }
55090
55091
55092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
55093   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
55094   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
55095
55096   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
55097   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
55098   {
55099     try {
55100       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55101     } catch (std::out_of_range& e) {
55102       {
55103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55104       };
55105     } catch (std::exception& e) {
55106       {
55107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55108       };
55109     } catch (Dali::DaliException e) {
55110       {
55111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55112       };
55113     } catch (...) {
55114       {
55115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55116       };
55117     }
55118   }
55119
55120 }
55121
55122
55123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
55124   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
55125   Dali::KeyEvent *arg2 = 0 ;
55126
55127   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
55128   arg2 = (Dali::KeyEvent *)jarg2;
55129   if (!arg2) {
55130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
55131     return ;
55132   }
55133   {
55134     try {
55135       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
55136     } catch (std::out_of_range& e) {
55137       {
55138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55139       };
55140     } catch (std::exception& e) {
55141       {
55142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55143       };
55144     } catch (Dali::DaliException e) {
55145       {
55146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55147       };
55148     } catch (...) {
55149       {
55150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55151       };
55152     }
55153   }
55154
55155 }
55156
55157
55158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
55159   void * jresult ;
55160   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
55161
55162   {
55163     try {
55164       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
55165     } catch (std::out_of_range& e) {
55166       {
55167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55168       };
55169     } catch (std::exception& e) {
55170       {
55171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55172       };
55173     } catch (Dali::DaliException e) {
55174       {
55175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55176       };
55177     } catch (...) {
55178       {
55179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55180       };
55181     }
55182   }
55183
55184   jresult = (void *)result;
55185   return jresult;
55186 }
55187
55188
55189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
55190   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
55191
55192   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
55193   {
55194     try {
55195       delete arg1;
55196     } catch (std::out_of_range& e) {
55197       {
55198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55199       };
55200     } catch (std::exception& e) {
55201       {
55202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55203       };
55204     } catch (Dali::DaliException e) {
55205       {
55206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55207       };
55208     } catch (...) {
55209       {
55210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55211       };
55212     }
55213   }
55214
55215 }
55216
55217
55218 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
55219   unsigned int jresult ;
55220   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
55221   bool result;
55222
55223   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
55224   {
55225     try {
55226       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
55227     } catch (std::out_of_range& e) {
55228       {
55229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55230       };
55231     } catch (std::exception& e) {
55232       {
55233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55234       };
55235     } catch (Dali::DaliException e) {
55236       {
55237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55238       };
55239     } catch (...) {
55240       {
55241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55242       };
55243     }
55244   }
55245
55246   jresult = result;
55247   return jresult;
55248 }
55249
55250
55251 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
55252   unsigned long jresult ;
55253   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
55254   std::size_t result;
55255
55256   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
55257   {
55258     try {
55259       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
55260     } catch (std::out_of_range& e) {
55261       {
55262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55263       };
55264     } catch (std::exception& e) {
55265       {
55266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55267       };
55268     } catch (Dali::DaliException e) {
55269       {
55270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55271       };
55272     } catch (...) {
55273       {
55274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55275       };
55276     }
55277   }
55278
55279   jresult = (unsigned long)result;
55280   return jresult;
55281 }
55282
55283
55284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
55285   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
55286   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
55287
55288   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
55289   arg2 = (void (*)(Dali::TouchData const &))jarg2;
55290   {
55291     try {
55292       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55293     } catch (std::out_of_range& e) {
55294       {
55295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55296       };
55297     } catch (std::exception& e) {
55298       {
55299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55300       };
55301     } catch (Dali::DaliException e) {
55302       {
55303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55304       };
55305     } catch (...) {
55306       {
55307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55308       };
55309     }
55310   }
55311
55312 }
55313
55314
55315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
55316   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
55317   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
55318
55319   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
55320   arg2 = (void (*)(Dali::TouchData const &))jarg2;
55321   {
55322     try {
55323       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55324     } catch (std::out_of_range& e) {
55325       {
55326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55327       };
55328     } catch (std::exception& e) {
55329       {
55330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55331       };
55332     } catch (Dali::DaliException e) {
55333       {
55334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55335       };
55336     } catch (...) {
55337       {
55338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55339       };
55340     }
55341   }
55342
55343 }
55344
55345
55346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
55347   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
55348   Dali::TouchData *arg2 = 0 ;
55349
55350   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
55351   arg2 = (Dali::TouchData *)jarg2;
55352   if (!arg2) {
55353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
55354     return ;
55355   }
55356   {
55357     try {
55358       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
55359     } catch (std::out_of_range& e) {
55360       {
55361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55362       };
55363     } catch (std::exception& e) {
55364       {
55365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55366       };
55367     } catch (Dali::DaliException e) {
55368       {
55369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55370       };
55371     } catch (...) {
55372       {
55373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55374       };
55375     }
55376   }
55377
55378 }
55379
55380
55381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
55382   void * jresult ;
55383   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
55384
55385   {
55386     try {
55387       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
55388     } catch (std::out_of_range& e) {
55389       {
55390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55391       };
55392     } catch (std::exception& e) {
55393       {
55394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55395       };
55396     } catch (Dali::DaliException e) {
55397       {
55398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55399       };
55400     } catch (...) {
55401       {
55402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55403       };
55404     }
55405   }
55406
55407   jresult = (void *)result;
55408   return jresult;
55409 }
55410
55411
55412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
55413   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
55414
55415   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
55416   {
55417     try {
55418       delete arg1;
55419     } catch (std::out_of_range& e) {
55420       {
55421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55422       };
55423     } catch (std::exception& e) {
55424       {
55425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55426       };
55427     } catch (Dali::DaliException e) {
55428       {
55429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55430       };
55431     } catch (...) {
55432       {
55433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55434       };
55435     }
55436   }
55437
55438 }
55439
55440
55441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
55442   unsigned int jresult ;
55443   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
55444   bool result;
55445
55446   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
55447   {
55448     try {
55449       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
55450     } catch (std::out_of_range& e) {
55451       {
55452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55453       };
55454     } catch (std::exception& e) {
55455       {
55456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55457       };
55458     } catch (Dali::DaliException e) {
55459       {
55460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55461       };
55462     } catch (...) {
55463       {
55464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55465       };
55466     }
55467   }
55468
55469   jresult = result;
55470   return jresult;
55471 }
55472
55473
55474 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
55475   unsigned long jresult ;
55476   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
55477   std::size_t result;
55478
55479   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
55480   {
55481     try {
55482       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
55483     } catch (std::out_of_range& e) {
55484       {
55485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55486       };
55487     } catch (std::exception& e) {
55488       {
55489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55490       };
55491     } catch (Dali::DaliException e) {
55492       {
55493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55494       };
55495     } catch (...) {
55496       {
55497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55498       };
55499     }
55500   }
55501
55502   jresult = (unsigned long)result;
55503   return jresult;
55504 }
55505
55506
55507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
55508   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
55509   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
55510
55511   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
55512   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
55513   {
55514     try {
55515       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55516     } catch (std::out_of_range& e) {
55517       {
55518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55519       };
55520     } catch (std::exception& e) {
55521       {
55522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55523       };
55524     } catch (Dali::DaliException e) {
55525       {
55526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55527       };
55528     } catch (...) {
55529       {
55530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55531       };
55532     }
55533   }
55534
55535 }
55536
55537
55538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
55539   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
55540   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
55541
55542   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
55543   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
55544   {
55545     try {
55546       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55547     } catch (std::out_of_range& e) {
55548       {
55549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55550       };
55551     } catch (std::exception& e) {
55552       {
55553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55554       };
55555     } catch (Dali::DaliException e) {
55556       {
55557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55558       };
55559     } catch (...) {
55560       {
55561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55562       };
55563     }
55564   }
55565
55566 }
55567
55568
55569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
55570   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
55571   Dali::WheelEvent *arg2 = 0 ;
55572
55573   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
55574   arg2 = (Dali::WheelEvent *)jarg2;
55575   if (!arg2) {
55576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
55577     return ;
55578   }
55579   {
55580     try {
55581       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
55582     } catch (std::out_of_range& e) {
55583       {
55584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55585       };
55586     } catch (std::exception& e) {
55587       {
55588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55589       };
55590     } catch (Dali::DaliException e) {
55591       {
55592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55593       };
55594     } catch (...) {
55595       {
55596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55597       };
55598     }
55599   }
55600
55601 }
55602
55603
55604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
55605   void * jresult ;
55606   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
55607
55608   {
55609     try {
55610       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
55611     } catch (std::out_of_range& e) {
55612       {
55613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55614       };
55615     } catch (std::exception& e) {
55616       {
55617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55618       };
55619     } catch (Dali::DaliException e) {
55620       {
55621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55622       };
55623     } catch (...) {
55624       {
55625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55626       };
55627     }
55628   }
55629
55630   jresult = (void *)result;
55631   return jresult;
55632 }
55633
55634
55635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
55636   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
55637
55638   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
55639   {
55640     try {
55641       delete arg1;
55642     } catch (std::out_of_range& e) {
55643       {
55644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55645       };
55646     } catch (std::exception& e) {
55647       {
55648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55649       };
55650     } catch (Dali::DaliException e) {
55651       {
55652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55653       };
55654     } catch (...) {
55655       {
55656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55657       };
55658     }
55659   }
55660
55661 }
55662
55663
55664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
55665   void * jresult ;
55666   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
55667
55668   {
55669     try {
55670       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
55671     } catch (std::out_of_range& e) {
55672       {
55673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55674       };
55675     } catch (std::exception& e) {
55676       {
55677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55678       };
55679     } catch (Dali::DaliException e) {
55680       {
55681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55682       };
55683     } catch (...) {
55684       {
55685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55686       };
55687     }
55688   }
55689
55690   jresult = (void *)result;
55691   return jresult;
55692 }
55693
55694
55695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
55696   void * jresult ;
55697   Dali::Radian arg1 ;
55698   Dali::Radian arg2 ;
55699   Dali::Radian *argp1 ;
55700   Dali::Radian *argp2 ;
55701   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
55702
55703   argp1 = (Dali::Radian *)jarg1;
55704   if (!argp1) {
55705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
55706     return 0;
55707   }
55708   arg1 = *argp1;
55709   argp2 = (Dali::Radian *)jarg2;
55710   if (!argp2) {
55711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
55712     return 0;
55713   }
55714   arg2 = *argp2;
55715   {
55716     try {
55717       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
55718     } catch (std::out_of_range& e) {
55719       {
55720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55721       };
55722     } catch (std::exception& e) {
55723       {
55724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55725       };
55726     } catch (Dali::DaliException e) {
55727       {
55728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55729       };
55730     } catch (...) {
55731       {
55732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55733       };
55734     }
55735   }
55736
55737   jresult = (void *)result;
55738   return jresult;
55739 }
55740
55741
55742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
55743   void * jresult ;
55744   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
55745   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
55746
55747   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55748   if (!arg1) {
55749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
55750     return 0;
55751   }
55752   {
55753     try {
55754       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
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 (Dali::DaliException e) {
55764       {
55765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55766       };
55767     } catch (...) {
55768       {
55769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55770       };
55771     }
55772   }
55773
55774   jresult = (void *)result;
55775   return jresult;
55776 }
55777
55778
55779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
55780   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
55781   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
55782
55783   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55784   arg2 = (Dali::Radian *)jarg2;
55785   if (arg1) (arg1)->first = *arg2;
55786 }
55787
55788
55789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
55790   void * jresult ;
55791   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
55792   Dali::Radian *result = 0 ;
55793
55794   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55795   result = (Dali::Radian *)& ((arg1)->first);
55796   jresult = (void *)result;
55797   return jresult;
55798 }
55799
55800
55801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
55802   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
55803   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
55804
55805   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55806   arg2 = (Dali::Radian *)jarg2;
55807   if (arg1) (arg1)->second = *arg2;
55808 }
55809
55810
55811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
55812   void * jresult ;
55813   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
55814   Dali::Radian *result = 0 ;
55815
55816   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55817   result = (Dali::Radian *)& ((arg1)->second);
55818   jresult = (void *)result;
55819   return jresult;
55820 }
55821
55822
55823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
55824   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
55825
55826   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
55827   {
55828     try {
55829       delete arg1;
55830     } catch (std::out_of_range& e) {
55831       {
55832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55833       };
55834     } catch (std::exception& e) {
55835       {
55836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55837       };
55838     } catch (Dali::DaliException e) {
55839       {
55840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55841       };
55842     } catch (...) {
55843       {
55844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55845       };
55846     }
55847   }
55848
55849 }
55850
55851
55852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
55853   unsigned int jresult ;
55854   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55855   bool result;
55856
55857   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55858   {
55859     try {
55860       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);
55861     } catch (std::out_of_range& e) {
55862       {
55863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55864       };
55865     } catch (std::exception& e) {
55866       {
55867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55868       };
55869     } catch (Dali::DaliException e) {
55870       {
55871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55872       };
55873     } catch (...) {
55874       {
55875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55876       };
55877     }
55878   }
55879
55880   jresult = result;
55881   return jresult;
55882 }
55883
55884
55885 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
55886   unsigned long jresult ;
55887   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55888   std::size_t result;
55889
55890   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55891   {
55892     try {
55893       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);
55894     } catch (std::out_of_range& e) {
55895       {
55896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55897       };
55898     } catch (std::exception& e) {
55899       {
55900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55901       };
55902     } catch (Dali::DaliException e) {
55903       {
55904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55905       };
55906     } catch (...) {
55907       {
55908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55909       };
55910     }
55911   }
55912
55913   jresult = (unsigned long)result;
55914   return jresult;
55915 }
55916
55917
55918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
55919   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55920   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
55921
55922   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55923   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
55924   {
55925     try {
55926       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
55927     } catch (std::out_of_range& e) {
55928       {
55929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55930       };
55931     } catch (std::exception& e) {
55932       {
55933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55934       };
55935     } catch (Dali::DaliException e) {
55936       {
55937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55938       };
55939     } catch (...) {
55940       {
55941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55942       };
55943     }
55944   }
55945
55946 }
55947
55948
55949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
55950   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55951   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
55952
55953   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55954   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
55955   {
55956     try {
55957       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
55958     } catch (std::out_of_range& e) {
55959       {
55960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55961       };
55962     } catch (std::exception& e) {
55963       {
55964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55965       };
55966     } catch (Dali::DaliException e) {
55967       {
55968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55969       };
55970     } catch (...) {
55971       {
55972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55973       };
55974     }
55975   }
55976
55977 }
55978
55979
55980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
55981   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
55982   Dali::Actor arg2 ;
55983   Dali::PanGesture *arg3 = 0 ;
55984   Dali::Actor *argp2 ;
55985
55986   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
55987   argp2 = (Dali::Actor *)jarg2;
55988   if (!argp2) {
55989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
55990     return ;
55991   }
55992   arg2 = *argp2;
55993   arg3 = (Dali::PanGesture *)jarg3;
55994   if (!arg3) {
55995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
55996     return ;
55997   }
55998   {
55999     try {
56000       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*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 (Dali::DaliException e) {
56010       {
56011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56012       };
56013     } catch (...) {
56014       {
56015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56016       };
56017     }
56018   }
56019
56020 }
56021
56022
56023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
56024   void * jresult ;
56025   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
56026
56027   {
56028     try {
56029       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
56030     } catch (std::out_of_range& e) {
56031       {
56032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56033       };
56034     } catch (std::exception& e) {
56035       {
56036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56037       };
56038     } catch (Dali::DaliException e) {
56039       {
56040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56041       };
56042     } catch (...) {
56043       {
56044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56045       };
56046     }
56047   }
56048
56049   jresult = (void *)result;
56050   return jresult;
56051 }
56052
56053
56054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
56055   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
56056
56057   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
56058   {
56059     try {
56060       delete arg1;
56061     } catch (std::out_of_range& e) {
56062       {
56063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56064       };
56065     } catch (std::exception& e) {
56066       {
56067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56068       };
56069     } catch (Dali::DaliException e) {
56070       {
56071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56072       };
56073     } catch (...) {
56074       {
56075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56076       };
56077     }
56078   }
56079
56080 }
56081
56082
56083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
56084   unsigned int jresult ;
56085   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
56086   bool result;
56087
56088   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
56089   {
56090     try {
56091       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);
56092     } catch (std::out_of_range& e) {
56093       {
56094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56095       };
56096     } catch (std::exception& e) {
56097       {
56098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56099       };
56100     } catch (Dali::DaliException e) {
56101       {
56102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56103       };
56104     } catch (...) {
56105       {
56106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56107       };
56108     }
56109   }
56110
56111   jresult = result;
56112   return jresult;
56113 }
56114
56115
56116 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
56117   unsigned long jresult ;
56118   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
56119   std::size_t result;
56120
56121   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
56122   {
56123     try {
56124       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);
56125     } catch (std::out_of_range& e) {
56126       {
56127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56128       };
56129     } catch (std::exception& e) {
56130       {
56131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56132       };
56133     } catch (Dali::DaliException e) {
56134       {
56135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56136       };
56137     } catch (...) {
56138       {
56139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56140       };
56141     }
56142   }
56143
56144   jresult = (unsigned long)result;
56145   return jresult;
56146 }
56147
56148
56149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
56150   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
56151   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
56152
56153   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
56154   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
56155   {
56156     try {
56157       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56158     } catch (std::out_of_range& e) {
56159       {
56160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56161       };
56162     } catch (std::exception& e) {
56163       {
56164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56165       };
56166     } catch (Dali::DaliException e) {
56167       {
56168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56169       };
56170     } catch (...) {
56171       {
56172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56173       };
56174     }
56175   }
56176
56177 }
56178
56179
56180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
56181   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
56182   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
56183
56184   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
56185   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
56186   {
56187     try {
56188       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56189     } catch (std::out_of_range& e) {
56190       {
56191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56192       };
56193     } catch (std::exception& e) {
56194       {
56195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56196       };
56197     } catch (Dali::DaliException e) {
56198       {
56199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56200       };
56201     } catch (...) {
56202       {
56203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56204       };
56205     }
56206   }
56207
56208 }
56209
56210
56211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56212   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
56213   Dali::Actor arg2 ;
56214   Dali::PinchGesture *arg3 = 0 ;
56215   Dali::Actor *argp2 ;
56216
56217   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
56218   argp2 = (Dali::Actor *)jarg2;
56219   if (!argp2) {
56220     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56221     return ;
56222   }
56223   arg2 = *argp2;
56224   arg3 = (Dali::PinchGesture *)jarg3;
56225   if (!arg3) {
56226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
56227     return ;
56228   }
56229   {
56230     try {
56231       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
56232     } catch (std::out_of_range& e) {
56233       {
56234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56235       };
56236     } catch (std::exception& e) {
56237       {
56238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56239       };
56240     } catch (Dali::DaliException e) {
56241       {
56242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56243       };
56244     } catch (...) {
56245       {
56246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56247       };
56248     }
56249   }
56250
56251 }
56252
56253
56254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
56255   void * jresult ;
56256   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
56257
56258   {
56259     try {
56260       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
56261     } catch (std::out_of_range& e) {
56262       {
56263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56264       };
56265     } catch (std::exception& e) {
56266       {
56267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56268       };
56269     } catch (Dali::DaliException e) {
56270       {
56271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56272       };
56273     } catch (...) {
56274       {
56275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56276       };
56277     }
56278   }
56279
56280   jresult = (void *)result;
56281   return jresult;
56282 }
56283
56284
56285 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
56286   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
56287
56288   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
56289   {
56290     try {
56291       delete arg1;
56292     } catch (std::out_of_range& e) {
56293       {
56294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56295       };
56296     } catch (std::exception& e) {
56297       {
56298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56299       };
56300     } catch (Dali::DaliException e) {
56301       {
56302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56303       };
56304     } catch (...) {
56305       {
56306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56307       };
56308     }
56309   }
56310
56311 }
56312
56313
56314 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
56315   unsigned int jresult ;
56316   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
56317   bool result;
56318
56319   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
56320   {
56321     try {
56322       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);
56323     } catch (std::out_of_range& e) {
56324       {
56325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56326       };
56327     } catch (std::exception& e) {
56328       {
56329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56330       };
56331     } catch (Dali::DaliException e) {
56332       {
56333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56334       };
56335     } catch (...) {
56336       {
56337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56338       };
56339     }
56340   }
56341
56342   jresult = result;
56343   return jresult;
56344 }
56345
56346
56347 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
56348   unsigned long jresult ;
56349   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
56350   std::size_t result;
56351
56352   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
56353   {
56354     try {
56355       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);
56356     } catch (std::out_of_range& e) {
56357       {
56358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56359       };
56360     } catch (std::exception& e) {
56361       {
56362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56363       };
56364     } catch (Dali::DaliException e) {
56365       {
56366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56367       };
56368     } catch (...) {
56369       {
56370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56371       };
56372     }
56373   }
56374
56375   jresult = (unsigned long)result;
56376   return jresult;
56377 }
56378
56379
56380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
56381   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
56382   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
56383
56384   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
56385   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
56386   {
56387     try {
56388       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
56389     } catch (std::out_of_range& e) {
56390       {
56391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56392       };
56393     } catch (std::exception& e) {
56394       {
56395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56396       };
56397     } catch (Dali::DaliException e) {
56398       {
56399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56400       };
56401     } catch (...) {
56402       {
56403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56404       };
56405     }
56406   }
56407
56408 }
56409
56410
56411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
56412   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
56413   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
56414
56415   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
56416   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
56417   {
56418     try {
56419       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
56420     } catch (std::out_of_range& e) {
56421       {
56422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56423       };
56424     } catch (std::exception& e) {
56425       {
56426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56427       };
56428     } catch (Dali::DaliException e) {
56429       {
56430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56431       };
56432     } catch (...) {
56433       {
56434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56435       };
56436     }
56437   }
56438
56439 }
56440
56441
56442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
56443   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
56444   Dali::Actor arg2 ;
56445   Dali::TapGesture *arg3 = 0 ;
56446   Dali::Actor *argp2 ;
56447
56448   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
56449   argp2 = (Dali::Actor *)jarg2;
56450   if (!argp2) {
56451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56452     return ;
56453   }
56454   arg2 = *argp2;
56455   arg3 = (Dali::TapGesture *)jarg3;
56456   if (!arg3) {
56457     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
56458     return ;
56459   }
56460   {
56461     try {
56462       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
56463     } catch (std::out_of_range& e) {
56464       {
56465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56466       };
56467     } catch (std::exception& e) {
56468       {
56469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56470       };
56471     } catch (Dali::DaliException e) {
56472       {
56473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56474       };
56475     } catch (...) {
56476       {
56477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56478       };
56479     }
56480   }
56481
56482 }
56483
56484
56485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
56486   void * jresult ;
56487   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
56488
56489   {
56490     try {
56491       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
56492     } catch (std::out_of_range& e) {
56493       {
56494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56495       };
56496     } catch (std::exception& e) {
56497       {
56498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56499       };
56500     } catch (Dali::DaliException e) {
56501       {
56502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56503       };
56504     } catch (...) {
56505       {
56506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56507       };
56508     }
56509   }
56510
56511   jresult = (void *)result;
56512   return jresult;
56513 }
56514
56515
56516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
56517   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
56518
56519   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
56520   {
56521     try {
56522       delete arg1;
56523     } catch (std::out_of_range& e) {
56524       {
56525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56526       };
56527     } catch (std::exception& e) {
56528       {
56529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56530       };
56531     } catch (Dali::DaliException e) {
56532       {
56533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56534       };
56535     } catch (...) {
56536       {
56537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56538       };
56539     }
56540   }
56541
56542 }
56543
56544 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Empty(void * jarg1) {
56545   unsigned int jresult ;
56546   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56547   bool result;
56548
56549   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56550   {
56551     try {
56552       result = (bool)Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Empty((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
56553     } catch (std::out_of_range& e) {
56554       {
56555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56556       };
56557     } catch (std::exception& e) {
56558       {
56559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56560       };
56561     } catch (Dali::DaliException e) {
56562       {
56563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56564       };
56565     } catch (...) {
56566       {
56567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56568       };
56569     }
56570   }
56571
56572   jresult = result;
56573   return jresult;
56574 }
56575
56576
56577 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ResourceImageSignal_GetConnectionCount(void * jarg1) {
56578   unsigned long jresult ;
56579   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56580   std::size_t result;
56581
56582   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56583   {
56584     try {
56585       result = Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::ResourceImage) > const *)arg1);
56586     } catch (std::out_of_range& e) {
56587       {
56588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56589       };
56590     } catch (std::exception& e) {
56591       {
56592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56593       };
56594     } catch (Dali::DaliException e) {
56595       {
56596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56597       };
56598     } catch (...) {
56599       {
56600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56601       };
56602     }
56603   }
56604
56605   jresult = (unsigned long)result;
56606   return jresult;
56607 }
56608
56609
56610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Connect(void * jarg1, void * jarg2) {
56611   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56612   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
56613
56614   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56615   arg2 = (void (*)(Dali::ResourceImage))jarg2;
56616   {
56617     try {
56618       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Connect(arg1,arg2);
56619     } catch (std::out_of_range& e) {
56620       {
56621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56622       };
56623     } catch (std::exception& e) {
56624       {
56625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56626       };
56627     } catch (Dali::DaliException e) {
56628       {
56629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56630       };
56631     } catch (...) {
56632       {
56633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56634       };
56635     }
56636   }
56637
56638 }
56639
56640
56641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Disconnect(void * jarg1, void * jarg2) {
56642   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56643   void (*arg2)(Dali::ResourceImage) = (void (*)(Dali::ResourceImage)) 0 ;
56644
56645   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56646   arg2 = (void (*)(Dali::ResourceImage))jarg2;
56647   {
56648     try {
56649       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Disconnect(arg1,arg2);
56650     } catch (std::out_of_range& e) {
56651       {
56652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56653       };
56654     } catch (std::exception& e) {
56655       {
56656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56657       };
56658     } catch (Dali::DaliException e) {
56659       {
56660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56661       };
56662     } catch (...) {
56663       {
56664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56665       };
56666     }
56667   }
56668
56669 }
56670
56671
56672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ResourceImageSignal_Emit(void * jarg1, void * jarg2) {
56673   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56674   Dali::ResourceImage arg2 ;
56675   Dali::ResourceImage *argp2 ;
56676
56677   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56678   argp2 = (Dali::ResourceImage *)jarg2;
56679   if (!argp2) {
56680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ResourceImage", 0);
56681     return ;
56682   }
56683   arg2 = *argp2;
56684   {
56685     try {
56686       Dali_Signal_Sl_void_Sp_Dali_ResourceImage_SP__Sg__Emit(arg1,arg2);
56687     } catch (std::out_of_range& e) {
56688       {
56689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56690       };
56691     } catch (std::exception& e) {
56692       {
56693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56694       };
56695     } catch (Dali::DaliException e) {
56696       {
56697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56698       };
56699     } catch (...) {
56700       {
56701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56702       };
56703     }
56704   }
56705
56706 }
56707
56708
56709 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ResourceImageSignal() {
56710   void * jresult ;
56711   Dali::Signal< void (Dali::ResourceImage) > *result = 0 ;
56712
56713   {
56714     try {
56715       result = (Dali::Signal< void (Dali::ResourceImage) > *)new Dali::Signal< void (Dali::ResourceImage) >();
56716     } catch (std::out_of_range& e) {
56717       {
56718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56719       };
56720     } catch (std::exception& e) {
56721       {
56722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56723       };
56724     } catch (Dali::DaliException e) {
56725       {
56726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56727       };
56728     } catch (...) {
56729       {
56730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56731       };
56732     }
56733   }
56734
56735   jresult = (void *)result;
56736   return jresult;
56737 }
56738
56739
56740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ResourceImageSignal(void * jarg1) {
56741   Dali::Signal< void (Dali::ResourceImage) > *arg1 = (Dali::Signal< void (Dali::ResourceImage) > *) 0 ;
56742
56743   arg1 = (Dali::Signal< void (Dali::ResourceImage) > *)jarg1;
56744   {
56745     try {
56746       delete arg1;
56747     } catch (std::out_of_range& e) {
56748       {
56749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56750       };
56751     } catch (std::exception& e) {
56752       {
56753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56754       };
56755     } catch (Dali::DaliException e) {
56756       {
56757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
56758       };
56759     } catch (...) {
56760       {
56761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
56762       };
56763     }
56764   }
56765
56766 }
56767
56768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
56769   unsigned int jresult ;
56770   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56771   bool result = false;
56772
56773   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56774   {
56775     try {
56776       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Empty((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
56777     } catch (std::out_of_range& e) {
56778       {
56779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56780       };
56781     } catch (std::exception& e) {
56782       {
56783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56784       };
56785     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56786   }
56787   jresult = result;
56788   return jresult;
56789 }
56790
56791 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
56792   unsigned long jresult ;
56793   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56794   std::size_t result = 0;
56795
56796   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56797   {
56798     try {
56799       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > const *)arg1);
56800     } catch (std::out_of_range& e) {
56801       {
56802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56803       };
56804     } catch (std::exception& e) {
56805       {
56806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56807       };
56808     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56809   }
56810   jresult = (unsigned long)result;
56811   return jresult;
56812 }
56813
56814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
56815   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56816   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
56817
56818   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56819   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
56820   {
56821     try {
56822       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
56823     } catch (std::out_of_range& e) {
56824       {
56825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56826       };
56827     } catch (std::exception& e) {
56828       {
56829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56830       };
56831     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56832   }
56833 }
56834
56835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
56836   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56837   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
56838
56839   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56840   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
56841   {
56842     try {
56843       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
56844     } catch (std::out_of_range& e) {
56845       {
56846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56847       };
56848     } catch (std::exception& e) {
56849       {
56850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56851       };
56852     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56853   }
56854 }
56855
56856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
56857   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56858   Dali::Actor arg2 ;
56859   //bool arg3 ;
56860   Dali::LayoutDirection::Type arg4 ;
56861   Dali::Actor *argp2 ;
56862
56863   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56864   argp2 = (Dali::Actor *)jarg2;
56865   if (!argp2) {
56866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
56867     return ;
56868   }
56869   arg2 = *argp2;
56870   //arg3 = jarg3 ? true : false;
56871   arg4 = (Dali::LayoutDirection::Type)jarg4;
56872   {
56873     try {
56874       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
56875     } catch (std::out_of_range& e) {
56876       {
56877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56878       };
56879     } catch (std::exception& e) {
56880       {
56881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56882       };
56883     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56884   }
56885 }
56886
56887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
56888   void * jresult ;
56889   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
56890
56891   {
56892     try {
56893       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
56894     } catch (std::out_of_range& e) {
56895       {
56896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56897       };
56898     } catch (std::exception& e) {
56899       {
56900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56901       };
56902     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56903   }
56904   jresult = (void *)result;
56905   return jresult;
56906 }
56907
56908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
56909   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
56910
56911   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
56912   {
56913     try {
56914       delete arg1;
56915     } catch (std::out_of_range& e) {
56916       {
56917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
56918       };
56919     } catch (std::exception& e) {
56920       {
56921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
56922       };
56923     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
56924   }
56925 }
56926
56927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
56928   unsigned int jresult ;
56929   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
56930   bool result;
56931
56932   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
56933   {
56934     try {
56935       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);
56936     } catch (std::out_of_range& e) {
56937       {
56938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56939       };
56940     } catch (std::exception& e) {
56941       {
56942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56943       };
56944     } catch (Dali::DaliException e) {
56945       {
56946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56947       };
56948     } catch (...) {
56949       {
56950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56951       };
56952     }
56953   }
56954
56955   jresult = result;
56956   return jresult;
56957 }
56958
56959
56960 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
56961   unsigned long jresult ;
56962   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
56963   std::size_t result;
56964
56965   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
56966   {
56967     try {
56968       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);
56969     } catch (std::out_of_range& e) {
56970       {
56971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56972       };
56973     } catch (std::exception& e) {
56974       {
56975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56976       };
56977     } catch (Dali::DaliException e) {
56978       {
56979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56980       };
56981     } catch (...) {
56982       {
56983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56984       };
56985     }
56986   }
56987
56988   jresult = (unsigned long)result;
56989   return jresult;
56990 }
56991
56992
56993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
56994   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
56995   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
56996
56997   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
56998   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
56999   {
57000     try {
57001       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
57002     } catch (std::out_of_range& e) {
57003       {
57004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57005       };
57006     } catch (std::exception& e) {
57007       {
57008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57009       };
57010     } catch (Dali::DaliException e) {
57011       {
57012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57013       };
57014     } catch (...) {
57015       {
57016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57017       };
57018     }
57019   }
57020
57021 }
57022
57023
57024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
57025   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
57026   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
57027
57028   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
57029   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
57030   {
57031     try {
57032       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
57033     } catch (std::out_of_range& e) {
57034       {
57035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57036       };
57037     } catch (std::exception& e) {
57038       {
57039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57040       };
57041     } catch (Dali::DaliException e) {
57042       {
57043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57044       };
57045     } catch (...) {
57046       {
57047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57048       };
57049     }
57050   }
57051
57052 }
57053
57054
57055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
57056   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
57057   Dali::Actor arg2 ;
57058   bool arg3 ;
57059   Dali::DevelActor::VisibilityChange::Type arg4 ;
57060   Dali::Actor *argp2 ;
57061
57062   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
57063   argp2 = (Dali::Actor *)jarg2;
57064   if (!argp2) {
57065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57066     return ;
57067   }
57068   arg2 = *argp2;
57069   arg3 = jarg3 ? true : false;
57070   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
57071   {
57072     try {
57073       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
57074     } catch (std::out_of_range& e) {
57075       {
57076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57077       };
57078     } catch (std::exception& e) {
57079       {
57080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57081       };
57082     } catch (Dali::DaliException e) {
57083       {
57084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57085       };
57086     } catch (...) {
57087       {
57088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57089       };
57090     }
57091   }
57092
57093 }
57094
57095
57096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
57097   void * jresult ;
57098   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
57099
57100   {
57101     try {
57102       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
57103     } catch (std::out_of_range& e) {
57104       {
57105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57106       };
57107     } catch (std::exception& e) {
57108       {
57109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57110       };
57111     } catch (Dali::DaliException e) {
57112       {
57113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57114       };
57115     } catch (...) {
57116       {
57117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57118       };
57119     }
57120   }
57121
57122   jresult = (void *)result;
57123   return jresult;
57124 }
57125
57126
57127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
57128   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
57129
57130   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
57131   {
57132     try {
57133       delete arg1;
57134     } catch (std::out_of_range& e) {
57135       {
57136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57137       };
57138     } catch (std::exception& e) {
57139       {
57140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57141       };
57142     } catch (Dali::DaliException e) {
57143       {
57144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57145       };
57146     } catch (...) {
57147       {
57148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57149       };
57150     }
57151   }
57152
57153 }
57154
57155
57156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
57157   void * jresult ;
57158   Dali::Timer *result = 0 ;
57159
57160   {
57161     try {
57162       result = (Dali::Timer *)new Dali::Timer();
57163     } catch (std::out_of_range& e) {
57164       {
57165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57166       };
57167     } catch (std::exception& e) {
57168       {
57169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57170       };
57171     } catch (Dali::DaliException e) {
57172       {
57173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57174       };
57175     } catch (...) {
57176       {
57177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57178       };
57179     }
57180   }
57181
57182   jresult = (void *)result;
57183   return jresult;
57184 }
57185
57186
57187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
57188   void * jresult ;
57189   unsigned int arg1 ;
57190   Dali::Timer result;
57191
57192   arg1 = (unsigned int)jarg1;
57193   {
57194     try {
57195       result = Dali::Timer::New(arg1);
57196     } catch (std::out_of_range& e) {
57197       {
57198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57199       };
57200     } catch (std::exception& e) {
57201       {
57202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57203       };
57204     } catch (Dali::DaliException e) {
57205       {
57206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57207       };
57208     } catch (...) {
57209       {
57210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57211       };
57212     }
57213   }
57214
57215   jresult = new Dali::Timer((const Dali::Timer &)result);
57216   return jresult;
57217 }
57218
57219
57220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
57221   void * jresult ;
57222   Dali::Timer *arg1 = 0 ;
57223   Dali::Timer *result = 0 ;
57224
57225   arg1 = (Dali::Timer *)jarg1;
57226   if (!arg1) {
57227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
57228     return 0;
57229   }
57230   {
57231     try {
57232       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
57233     } catch (std::out_of_range& e) {
57234       {
57235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57236       };
57237     } catch (std::exception& e) {
57238       {
57239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57240       };
57241     } catch (Dali::DaliException e) {
57242       {
57243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57244       };
57245     } catch (...) {
57246       {
57247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57248       };
57249     }
57250   }
57251
57252   jresult = (void *)result;
57253   return jresult;
57254 }
57255
57256
57257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
57258   void * jresult ;
57259   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
57260   Dali::Timer *arg2 = 0 ;
57261   Dali::Timer *result = 0 ;
57262
57263   arg1 = (Dali::Timer *)jarg1;
57264   arg2 = (Dali::Timer *)jarg2;
57265   if (!arg2) {
57266     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
57267     return 0;
57268   }
57269   {
57270     try {
57271       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
57272     } catch (std::out_of_range& e) {
57273       {
57274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57275       };
57276     } catch (std::exception& e) {
57277       {
57278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57279       };
57280     } catch (Dali::DaliException e) {
57281       {
57282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57283       };
57284     } catch (...) {
57285       {
57286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57287       };
57288     }
57289   }
57290
57291   jresult = (void *)result;
57292   return jresult;
57293 }
57294
57295
57296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
57297   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
57298
57299   arg1 = (Dali::Timer *)jarg1;
57300   {
57301     try {
57302       delete arg1;
57303     } catch (std::out_of_range& e) {
57304       {
57305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57306       };
57307     } catch (std::exception& e) {
57308       {
57309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57310       };
57311     } catch (Dali::DaliException e) {
57312       {
57313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57314       };
57315     } catch (...) {
57316       {
57317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57318       };
57319     }
57320   }
57321
57322 }
57323
57324
57325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
57326   void * jresult ;
57327   Dali::BaseHandle arg1 ;
57328   Dali::BaseHandle *argp1 ;
57329   Dali::Timer result;
57330
57331   argp1 = (Dali::BaseHandle *)jarg1;
57332   if (!argp1) {
57333     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
57334     return 0;
57335   }
57336   arg1 = *argp1;
57337   {
57338     try {
57339       result = Dali::Timer::DownCast(arg1);
57340     } catch (std::out_of_range& e) {
57341       {
57342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57343       };
57344     } catch (std::exception& e) {
57345       {
57346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57347       };
57348     } catch (Dali::DaliException e) {
57349       {
57350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57351       };
57352     } catch (...) {
57353       {
57354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57355       };
57356     }
57357   }
57358
57359   jresult = new Dali::Timer((const Dali::Timer &)result);
57360   return jresult;
57361 }
57362
57363
57364 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
57365   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
57366
57367   arg1 = (Dali::Timer *)jarg1;
57368   {
57369     try {
57370       (arg1)->Start();
57371     } catch (std::out_of_range& e) {
57372       {
57373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57374       };
57375     } catch (std::exception& e) {
57376       {
57377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57378       };
57379     } catch (Dali::DaliException e) {
57380       {
57381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57382       };
57383     } catch (...) {
57384       {
57385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57386       };
57387     }
57388   }
57389
57390 }
57391
57392
57393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
57394   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
57395
57396   arg1 = (Dali::Timer *)jarg1;
57397   {
57398     try {
57399       (arg1)->Stop();
57400     } catch (std::out_of_range& e) {
57401       {
57402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57403       };
57404     } catch (std::exception& e) {
57405       {
57406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57407       };
57408     } catch (Dali::DaliException e) {
57409       {
57410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57411       };
57412     } catch (...) {
57413       {
57414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57415       };
57416     }
57417   }
57418
57419 }
57420
57421
57422 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
57423   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
57424   unsigned int arg2 ;
57425
57426   arg1 = (Dali::Timer *)jarg1;
57427   arg2 = (unsigned int)jarg2;
57428   {
57429     try {
57430       (arg1)->SetInterval(arg2);
57431     } catch (std::out_of_range& e) {
57432       {
57433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57434       };
57435     } catch (std::exception& e) {
57436       {
57437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57438       };
57439     } catch (Dali::DaliException e) {
57440       {
57441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57442       };
57443     } catch (...) {
57444       {
57445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57446       };
57447     }
57448   }
57449
57450 }
57451
57452
57453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
57454   unsigned int jresult ;
57455   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
57456   unsigned int result;
57457
57458   arg1 = (Dali::Timer *)jarg1;
57459   {
57460     try {
57461       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
57462     } catch (std::out_of_range& e) {
57463       {
57464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57465       };
57466     } catch (std::exception& e) {
57467       {
57468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57469       };
57470     } catch (Dali::DaliException e) {
57471       {
57472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57473       };
57474     } catch (...) {
57475       {
57476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57477       };
57478     }
57479   }
57480
57481   jresult = result;
57482   return jresult;
57483 }
57484
57485
57486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
57487   unsigned int jresult ;
57488   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
57489   bool result;
57490
57491   arg1 = (Dali::Timer *)jarg1;
57492   {
57493     try {
57494       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
57495     } catch (std::out_of_range& e) {
57496       {
57497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57498       };
57499     } catch (std::exception& e) {
57500       {
57501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57502       };
57503     } catch (Dali::DaliException e) {
57504       {
57505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57506       };
57507     } catch (...) {
57508       {
57509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57510       };
57511     }
57512   }
57513
57514   jresult = result;
57515   return jresult;
57516 }
57517
57518
57519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
57520   void * jresult ;
57521   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
57522   Dali::Timer::TimerSignalType *result = 0 ;
57523
57524   arg1 = (Dali::Timer *)jarg1;
57525   {
57526     try {
57527       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
57528     } catch (std::out_of_range& e) {
57529       {
57530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57531       };
57532     } catch (std::exception& e) {
57533       {
57534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57535       };
57536     } catch (Dali::DaliException e) {
57537       {
57538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57539       };
57540     } catch (...) {
57541       {
57542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57543       };
57544     }
57545   }
57546
57547   jresult = (void *)result;
57548   return jresult;
57549 }
57550
57551
57552 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
57553   unsigned int jresult ;
57554   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57555   bool result;
57556
57557   arg1 = (Dali::Signal< bool () > *)jarg1;
57558   {
57559     try {
57560       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
57561     } catch (std::out_of_range& e) {
57562       {
57563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57564       };
57565     } catch (std::exception& e) {
57566       {
57567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57568       };
57569     } catch (Dali::DaliException e) {
57570       {
57571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57572       };
57573     } catch (...) {
57574       {
57575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57576       };
57577     }
57578   }
57579
57580   jresult = result;
57581   return jresult;
57582 }
57583
57584
57585 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
57586   unsigned long jresult ;
57587   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57588   std::size_t result;
57589
57590   arg1 = (Dali::Signal< bool () > *)jarg1;
57591   {
57592     try {
57593       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
57594     } catch (std::out_of_range& e) {
57595       {
57596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57597       };
57598     } catch (std::exception& e) {
57599       {
57600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57601       };
57602     } catch (Dali::DaliException e) {
57603       {
57604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57605       };
57606     } catch (...) {
57607       {
57608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57609       };
57610     }
57611   }
57612
57613   jresult = (unsigned long)result;
57614   return jresult;
57615 }
57616
57617
57618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
57619   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57620   bool (*arg2)() = (bool (*)()) 0 ;
57621
57622   arg1 = (Dali::Signal< bool () > *)jarg1;
57623   arg2 = (bool (*)())jarg2;
57624   {
57625     try {
57626       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
57627     } catch (std::out_of_range& e) {
57628       {
57629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57630       };
57631     } catch (std::exception& e) {
57632       {
57633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57634       };
57635     } catch (Dali::DaliException e) {
57636       {
57637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57638       };
57639     } catch (...) {
57640       {
57641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57642       };
57643     }
57644   }
57645
57646 }
57647
57648
57649 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
57650   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57651   bool (*arg2)() = (bool (*)()) 0 ;
57652
57653   arg1 = (Dali::Signal< bool () > *)jarg1;
57654   arg2 = (bool (*)())jarg2;
57655   {
57656     try {
57657       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
57658     } catch (std::out_of_range& e) {
57659       {
57660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57661       };
57662     } catch (std::exception& e) {
57663       {
57664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57665       };
57666     } catch (Dali::DaliException e) {
57667       {
57668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57669       };
57670     } catch (...) {
57671       {
57672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57673       };
57674     }
57675   }
57676
57677 }
57678
57679
57680 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
57681   unsigned int jresult ;
57682   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57683   bool result;
57684
57685   arg1 = (Dali::Signal< bool () > *)jarg1;
57686   {
57687     try {
57688       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
57689     } catch (std::out_of_range& e) {
57690       {
57691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57692       };
57693     } catch (std::exception& e) {
57694       {
57695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57696       };
57697     } catch (Dali::DaliException e) {
57698       {
57699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57700       };
57701     } catch (...) {
57702       {
57703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57704       };
57705     }
57706   }
57707
57708   jresult = result;
57709   return jresult;
57710 }
57711
57712
57713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
57714   void * jresult ;
57715   Dali::Signal< bool () > *result = 0 ;
57716
57717   {
57718     try {
57719       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
57720     } catch (std::out_of_range& e) {
57721       {
57722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57723       };
57724     } catch (std::exception& e) {
57725       {
57726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57727       };
57728     } catch (Dali::DaliException e) {
57729       {
57730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57731       };
57732     } catch (...) {
57733       {
57734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57735       };
57736     }
57737   }
57738
57739   jresult = (void *)result;
57740   return jresult;
57741 }
57742
57743
57744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
57745   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
57746
57747   arg1 = (Dali::Signal< bool () > *)jarg1;
57748   {
57749     try {
57750       delete arg1;
57751     } catch (std::out_of_range& e) {
57752       {
57753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57754       };
57755     } catch (std::exception& e) {
57756       {
57757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57758       };
57759     } catch (Dali::DaliException e) {
57760       {
57761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57762       };
57763     } catch (...) {
57764       {
57765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57766       };
57767     }
57768   }
57769
57770 }
57771
57772
57773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
57774   int jresult ;
57775   int result;
57776
57777   {
57778     try {
57779       result = (int)Dali::Toolkit::Visual::Property::TYPE;
57780     } catch (std::out_of_range& e) {
57781       {
57782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57783       };
57784     } catch (std::exception& e) {
57785       {
57786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57787       };
57788     } catch (Dali::DaliException e) {
57789       {
57790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57791       };
57792     } catch (...) {
57793       {
57794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57795       };
57796     }
57797   }
57798
57799   jresult = (int)result;
57800   return jresult;
57801 }
57802
57803
57804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
57805   int jresult ;
57806   int result;
57807
57808   {
57809     try {
57810       result = (int)Dali::Toolkit::Visual::Property::SHADER;
57811     } catch (std::out_of_range& e) {
57812       {
57813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57814       };
57815     } catch (std::exception& e) {
57816       {
57817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57818       };
57819     } catch (Dali::DaliException e) {
57820       {
57821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57822       };
57823     } catch (...) {
57824       {
57825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57826       };
57827     }
57828   }
57829
57830   jresult = (int)result;
57831   return jresult;
57832 }
57833
57834
57835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
57836   int jresult ;
57837   int result;
57838
57839   {
57840     try {
57841       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
57842     } catch (std::out_of_range& e) {
57843       {
57844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57845       };
57846     } catch (std::exception& e) {
57847       {
57848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57849       };
57850     } catch (Dali::DaliException e) {
57851       {
57852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57853       };
57854     } catch (...) {
57855       {
57856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57857       };
57858     }
57859   }
57860
57861   jresult = (int)result;
57862   return jresult;
57863 }
57864
57865
57866 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
57867   int jresult ;
57868   int result;
57869
57870   {
57871     try {
57872       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
57873     } catch (std::out_of_range& e) {
57874       {
57875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57876       };
57877     } catch (std::exception& e) {
57878       {
57879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57880       };
57881     } catch (Dali::DaliException e) {
57882       {
57883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57884       };
57885     } catch (...) {
57886       {
57887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57888       };
57889     }
57890   }
57891
57892   jresult = (int)result;
57893   return jresult;
57894 }
57895
57896
57897 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
57898   int jresult ;
57899   int result;
57900
57901   {
57902     try {
57903       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
57904     } catch (std::out_of_range& e) {
57905       {
57906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57907       };
57908     } catch (std::exception& e) {
57909       {
57910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57911       };
57912     } catch (Dali::DaliException e) {
57913       {
57914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57915       };
57916     } catch (...) {
57917       {
57918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57919       };
57920     }
57921   }
57922
57923   jresult = (int)result;
57924   return jresult;
57925 }
57926
57927
57928 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
57929   int jresult ;
57930   int result;
57931
57932   {
57933     try {
57934       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
57935     } catch (std::out_of_range& e) {
57936       {
57937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57938       };
57939     } catch (std::exception& e) {
57940       {
57941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57942       };
57943     } catch (Dali::DaliException e) {
57944       {
57945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57946       };
57947     } catch (...) {
57948       {
57949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57950       };
57951     }
57952   }
57953
57954   jresult = (int)result;
57955   return jresult;
57956 }
57957
57958
57959 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
57960   int jresult ;
57961   int result;
57962
57963   {
57964     try {
57965       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
57966     } catch (std::out_of_range& e) {
57967       {
57968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57969       };
57970     } catch (std::exception& e) {
57971       {
57972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57973       };
57974     } catch (Dali::DaliException e) {
57975       {
57976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57977       };
57978     } catch (...) {
57979       {
57980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57981       };
57982     }
57983   }
57984
57985   jresult = (int)result;
57986   return jresult;
57987 }
57988
57989
57990 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
57991   int jresult ;
57992   int result;
57993
57994   {
57995     try {
57996       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
57997     } catch (std::out_of_range& e) {
57998       {
57999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58000       };
58001     } catch (std::exception& e) {
58002       {
58003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58004       };
58005     } catch (Dali::DaliException e) {
58006       {
58007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58008       };
58009     } catch (...) {
58010       {
58011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58012       };
58013     }
58014   }
58015
58016   jresult = (int)result;
58017   return jresult;
58018 }
58019
58020
58021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
58022   int jresult ;
58023   int result;
58024
58025   {
58026     try {
58027       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
58028     } catch (std::out_of_range& e) {
58029       {
58030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58031       };
58032     } catch (std::exception& e) {
58033       {
58034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58035       };
58036     } catch (Dali::DaliException e) {
58037       {
58038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58039       };
58040     } catch (...) {
58041       {
58042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58043       };
58044     }
58045   }
58046
58047   jresult = (int)result;
58048   return jresult;
58049 }
58050
58051
58052 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
58053   int jresult ;
58054   int result;
58055
58056   {
58057     try {
58058       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
58059     } catch (std::out_of_range& e) {
58060       {
58061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58062       };
58063     } catch (std::exception& e) {
58064       {
58065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58066       };
58067     } catch (Dali::DaliException e) {
58068       {
58069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58070       };
58071     } catch (...) {
58072       {
58073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58074       };
58075     }
58076   }
58077
58078   jresult = (int)result;
58079   return jresult;
58080 }
58081
58082
58083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
58084   int jresult ;
58085   int result;
58086
58087   {
58088     try {
58089       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
58090     } catch (std::out_of_range& e) {
58091       {
58092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58093       };
58094     } catch (std::exception& e) {
58095       {
58096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58097       };
58098     } catch (Dali::DaliException e) {
58099       {
58100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58101       };
58102     } catch (...) {
58103       {
58104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58105       };
58106     }
58107   }
58108
58109   jresult = (int)result;
58110   return jresult;
58111 }
58112
58113
58114 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
58115   int jresult ;
58116   int result;
58117
58118   {
58119     try {
58120       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
58121     } catch (std::out_of_range& e) {
58122       {
58123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58124       };
58125     } catch (std::exception& e) {
58126       {
58127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58128       };
58129     } catch (Dali::DaliException e) {
58130       {
58131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58132       };
58133     } catch (...) {
58134       {
58135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58136       };
58137     }
58138   }
58139
58140   jresult = (int)result;
58141   return jresult;
58142 }
58143
58144
58145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
58146   int jresult ;
58147   int result;
58148
58149   {
58150     try {
58151       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
58152     } catch (std::out_of_range& e) {
58153       {
58154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58155       };
58156     } catch (std::exception& e) {
58157       {
58158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58159       };
58160     } catch (Dali::DaliException e) {
58161       {
58162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58163       };
58164     } catch (...) {
58165       {
58166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58167       };
58168     }
58169   }
58170
58171   jresult = (int)result;
58172   return jresult;
58173 }
58174
58175
58176 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
58177   int jresult ;
58178   int result;
58179
58180   {
58181     try {
58182       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
58183     } catch (std::out_of_range& e) {
58184       {
58185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58186       };
58187     } catch (std::exception& e) {
58188       {
58189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58190       };
58191     } catch (Dali::DaliException e) {
58192       {
58193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58194       };
58195     } catch (...) {
58196       {
58197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58198       };
58199     }
58200   }
58201
58202   jresult = (int)result;
58203   return jresult;
58204 }
58205
58206
58207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
58208   int jresult ;
58209   int result;
58210
58211   {
58212     try {
58213       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
58214     } catch (std::out_of_range& e) {
58215       {
58216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58217       };
58218     } catch (std::exception& e) {
58219       {
58220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58221       };
58222     } catch (Dali::DaliException e) {
58223       {
58224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58225       };
58226     } catch (...) {
58227       {
58228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58229       };
58230     }
58231   }
58232
58233   jresult = (int)result;
58234   return jresult;
58235 }
58236
58237
58238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
58239   int jresult ;
58240   int result;
58241
58242   {
58243     try {
58244       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
58245     } catch (std::out_of_range& e) {
58246       {
58247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58248       };
58249     } catch (std::exception& e) {
58250       {
58251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58252       };
58253     } catch (Dali::DaliException e) {
58254       {
58255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58256       };
58257     } catch (...) {
58258       {
58259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58260       };
58261     }
58262   }
58263
58264   jresult = (int)result;
58265   return jresult;
58266 }
58267
58268
58269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
58270   int jresult ;
58271   int result;
58272
58273   {
58274     try {
58275       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
58276     } catch (std::out_of_range& e) {
58277       {
58278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58279       };
58280     } catch (std::exception& e) {
58281       {
58282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58283       };
58284     } catch (Dali::DaliException e) {
58285       {
58286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58287       };
58288     } catch (...) {
58289       {
58290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58291       };
58292     }
58293   }
58294
58295   jresult = (int)result;
58296   return jresult;
58297 }
58298
58299
58300 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
58301   int jresult ;
58302   int result;
58303
58304   {
58305     try {
58306       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
58307     } catch (std::out_of_range& e) {
58308       {
58309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58310       };
58311     } catch (std::exception& e) {
58312       {
58313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58314       };
58315     } catch (Dali::DaliException e) {
58316       {
58317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58318       };
58319     } catch (...) {
58320       {
58321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58322       };
58323     }
58324   }
58325
58326   jresult = (int)result;
58327   return jresult;
58328 }
58329
58330
58331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
58332   int jresult ;
58333   int result;
58334
58335   {
58336     try {
58337       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
58338     } catch (std::out_of_range& e) {
58339       {
58340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58341       };
58342     } catch (std::exception& e) {
58343       {
58344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58345       };
58346     } catch (Dali::DaliException e) {
58347       {
58348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58349       };
58350     } catch (...) {
58351       {
58352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58353       };
58354     }
58355   }
58356
58357   jresult = (int)result;
58358   return jresult;
58359 }
58360
58361
58362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
58363   int jresult ;
58364   int result;
58365
58366   {
58367     try {
58368       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
58369     } catch (std::out_of_range& e) {
58370       {
58371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58372       };
58373     } catch (std::exception& e) {
58374       {
58375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58376       };
58377     } catch (Dali::DaliException e) {
58378       {
58379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58380       };
58381     } catch (...) {
58382       {
58383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58384       };
58385     }
58386   }
58387
58388   jresult = (int)result;
58389   return jresult;
58390 }
58391
58392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
58393   int jresult ;
58394   int result;
58395
58396   {
58397     try {
58398       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
58399     } catch (std::out_of_range& e) {
58400       {
58401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58402       };
58403     } catch (std::exception& e) {
58404       {
58405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58406       };
58407     } catch (Dali::DaliException e) {
58408       {
58409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58410       };
58411     } catch (...) {
58412       {
58413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58414       };
58415     }
58416   }
58417
58418   jresult = (int)result;
58419   return jresult;
58420 }
58421
58422
58423 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
58424   int jresult ;
58425   int result;
58426   {
58427     try
58428     {
58429       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
58430     } catch (std::out_of_range& e) {
58431       {
58432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58433       };
58434     } catch (std::exception& e) {
58435       {
58436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58437       };
58438     } catch (Dali::DaliException e) {
58439       {
58440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58441       };
58442     } catch (...) {
58443       {
58444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58445       };
58446     }
58447   }
58448
58449   jresult = (int)result;
58450   return jresult;
58451 }
58452
58453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
58454   int jresult ;
58455   int result;
58456   {
58457     try
58458     {
58459       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
58460     } catch (std::out_of_range& e) {
58461       {
58462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58463       };
58464     } catch (std::exception& e) {
58465       {
58466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58467       };
58468     } catch (Dali::DaliException e) {
58469       {
58470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58471       };
58472     } catch (...) {
58473       {
58474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58475       };
58476     }
58477   }
58478
58479   jresult = (int)result;
58480   return jresult;
58481 }
58482
58483 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
58484   int jresult ;
58485   int result;
58486   {
58487     try
58488     {
58489       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
58490     } catch (std::out_of_range& e) {
58491       {
58492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58493       };
58494     } catch (std::exception& e) {
58495       {
58496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58497       };
58498     } catch (Dali::DaliException e) {
58499       {
58500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58501       };
58502     } catch (...) {
58503       {
58504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58505       };
58506     }
58507   }
58508
58509   jresult = (int)result;
58510   return jresult;
58511 }
58512
58513 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
58514   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
58515 }
58516
58517 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
58518   int jresult ;
58519   int result;
58520   {
58521     try
58522     {
58523       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
58524     } catch (std::out_of_range& e) {
58525       {
58526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58527       };
58528     } catch (std::exception& e) {
58529       {
58530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58531       };
58532     } catch (Dali::DaliException e) {
58533       {
58534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58535       };
58536     } catch (...) {
58537       {
58538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58539       };
58540     }
58541   }
58542
58543   jresult = (int)result;
58544   return jresult;
58545 }
58546
58547 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
58548   int jresult ;
58549   int result;
58550   {
58551     try
58552     {
58553       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
58554     } catch (std::out_of_range& e) {
58555       {
58556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58557       };
58558     } catch (std::exception& e) {
58559       {
58560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58561       };
58562     } catch (Dali::DaliException e) {
58563       {
58564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58565       };
58566     } catch (...) {
58567       {
58568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58569       };
58570     }
58571   }
58572
58573   jresult = (int)result;
58574   return jresult;
58575 }
58576
58577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
58578   int jresult ;
58579   int result;
58580
58581   {
58582     try {
58583       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
58584     } catch (std::out_of_range& e) {
58585       {
58586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58587       };
58588     } catch (std::exception& e) {
58589       {
58590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58591       };
58592     } catch (Dali::DaliException e) {
58593       {
58594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58595       };
58596     } catch (...) {
58597       {
58598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58599       };
58600     }
58601   }
58602
58603   jresult = (int)result;
58604   return jresult;
58605 }
58606
58607
58608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
58609   int jresult ;
58610   int result;
58611
58612   {
58613     try {
58614       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
58615     } catch (std::out_of_range& e) {
58616       {
58617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58618       };
58619     } catch (std::exception& e) {
58620       {
58621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58622       };
58623     } catch (Dali::DaliException e) {
58624       {
58625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58626       };
58627     } catch (...) {
58628       {
58629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58630       };
58631     }
58632   }
58633
58634   jresult = (int)result;
58635   return jresult;
58636 }
58637
58638 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
58639   int jresult ;
58640   int result;
58641   {
58642     try
58643     {
58644       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
58645     } catch (std::out_of_range& e) {
58646       {
58647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58648       };
58649     } catch (std::exception& e) {
58650       {
58651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58652       };
58653     } catch (...) {
58654       {
58655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58656       };
58657     }
58658   }
58659   jresult = (int)result;
58660   return jresult;
58661 }
58662
58663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
58664   int jresult ;
58665   int result;
58666   {
58667     try
58668     {
58669       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
58670     } catch (std::out_of_range& e) {
58671       {
58672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58673       };
58674     } catch (std::exception& e) {
58675       {
58676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58677       };
58678     } catch (...) {
58679       {
58680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58681       };
58682     }
58683   }
58684   jresult = (int)result;
58685   return jresult;
58686 }
58687
58688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
58689   int jresult ;
58690   int result;
58691   {
58692     try
58693     {
58694       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
58695     } catch (std::out_of_range& e) {
58696       {
58697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58698       };
58699     } catch (std::exception& e) {
58700       {
58701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58702       };
58703     } catch (...) {
58704       {
58705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58706       };
58707     }
58708   }
58709   jresult = (int)result;
58710   return jresult;
58711 }
58712
58713
58714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
58715   int jresult ;
58716   int result;
58717   {
58718     try
58719     {
58720       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
58721     } catch (std::out_of_range& e) {
58722       {
58723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58724       };
58725     } catch (std::exception& e) {
58726       {
58727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58728       };
58729     } catch (...) {
58730       {
58731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58732       };
58733     }
58734   }
58735   jresult = (int)result;
58736   return jresult;
58737 }
58738
58739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
58740   int jresult ;
58741   int result;
58742   {
58743     try
58744     {
58745       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
58746     } catch (std::out_of_range& e) {
58747       {
58748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58749       };
58750     } catch (std::exception& e) {
58751       {
58752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58753       };
58754     } catch (...) {
58755       {
58756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58757       };
58758     }
58759   }
58760   jresult = (int)result;
58761   return jresult;
58762 }
58763
58764
58765
58766 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
58767   int jresult ;
58768   int result;
58769
58770   {
58771     try {
58772       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
58773     } catch (std::out_of_range& e) {
58774       {
58775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58776       };
58777     } catch (std::exception& e) {
58778       {
58779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58780       };
58781     } catch (Dali::DaliException e) {
58782       {
58783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58784       };
58785     } catch (...) {
58786       {
58787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58788       };
58789     }
58790   }
58791
58792   jresult = (int)result;
58793   return jresult;
58794 }
58795
58796
58797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
58798   int jresult ;
58799   int result;
58800
58801   {
58802     try {
58803       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
58804     } catch (std::out_of_range& e) {
58805       {
58806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58807       };
58808     } catch (std::exception& e) {
58809       {
58810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58811       };
58812     } catch (Dali::DaliException e) {
58813       {
58814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58815       };
58816     } catch (...) {
58817       {
58818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58819       };
58820     }
58821   }
58822
58823   jresult = (int)result;
58824   return jresult;
58825 }
58826
58827
58828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
58829   int jresult ;
58830   int result;
58831
58832   {
58833     try {
58834       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
58835     } catch (std::out_of_range& e) {
58836       {
58837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58838       };
58839     } catch (std::exception& e) {
58840       {
58841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58842       };
58843     } catch (Dali::DaliException e) {
58844       {
58845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58846       };
58847     } catch (...) {
58848       {
58849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58850       };
58851     }
58852   }
58853
58854   jresult = (int)result;
58855   return jresult;
58856 }
58857
58858
58859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
58860   int jresult ;
58861   int result;
58862
58863   {
58864     try {
58865       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
58866     } catch (std::out_of_range& e) {
58867       {
58868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58869       };
58870     } catch (std::exception& e) {
58871       {
58872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58873       };
58874     } catch (Dali::DaliException e) {
58875       {
58876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58877       };
58878     } catch (...) {
58879       {
58880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58881       };
58882     }
58883   }
58884
58885   jresult = (int)result;
58886   return jresult;
58887 }
58888
58889
58890 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
58891   int jresult ;
58892   int result;
58893
58894   {
58895     try {
58896       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
58897     } catch (std::out_of_range& e) {
58898       {
58899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58900       };
58901     } catch (std::exception& e) {
58902       {
58903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58904       };
58905     } catch (Dali::DaliException e) {
58906       {
58907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58908       };
58909     } catch (...) {
58910       {
58911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58912       };
58913     }
58914   }
58915
58916   jresult = (int)result;
58917   return jresult;
58918 }
58919
58920
58921 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
58922   int jresult ;
58923   int result;
58924
58925   {
58926     try {
58927       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
58928     } catch (std::out_of_range& e) {
58929       {
58930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58931       };
58932     } catch (std::exception& e) {
58933       {
58934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58935       };
58936     } catch (Dali::DaliException e) {
58937       {
58938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58939       };
58940     } catch (...) {
58941       {
58942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58943       };
58944     }
58945   }
58946
58947   jresult = (int)result;
58948   return jresult;
58949 }
58950
58951
58952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
58953   int jresult ;
58954   int result;
58955
58956   {
58957     try {
58958       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
58959     } catch (std::out_of_range& e) {
58960       {
58961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58962       };
58963     } catch (std::exception& e) {
58964       {
58965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58966       };
58967     } catch (Dali::DaliException e) {
58968       {
58969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58970       };
58971     } catch (...) {
58972       {
58973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58974       };
58975     }
58976   }
58977
58978   jresult = (int)result;
58979   return jresult;
58980 }
58981
58982 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
58983   int jresult ;
58984   int result;
58985
58986   {
58987     try {
58988       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
58989     } catch (std::out_of_range& e) {
58990       {
58991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58992       };
58993     } catch (std::exception& e) {
58994       {
58995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58996       };
58997     } catch (...) {
58998       {
58999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59000       };
59001     }
59002   }
59003   jresult = (int)result;
59004   return jresult;
59005 }
59006
59007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
59008   int jresult ;
59009   int result;
59010
59011   {
59012     try {
59013       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
59014     } catch (std::out_of_range& e) {
59015       {
59016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59017       };
59018     } catch (std::exception& e) {
59019       {
59020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59021       };
59022     } catch (Dali::DaliException e) {
59023       {
59024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59025       };
59026     } catch (...) {
59027       {
59028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59029       };
59030     }
59031   }
59032
59033   jresult = (int)result;
59034   return jresult;
59035 }
59036
59037
59038 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
59039   int jresult ;
59040   int result;
59041
59042   {
59043     try {
59044       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
59045     } catch (std::out_of_range& e) {
59046       {
59047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59048       };
59049     } catch (std::exception& e) {
59050       {
59051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59052       };
59053     } catch (Dali::DaliException e) {
59054       {
59055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59056       };
59057     } catch (...) {
59058       {
59059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59060       };
59061     }
59062   }
59063
59064   jresult = (int)result;
59065   return jresult;
59066 }
59067
59068
59069 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
59070   int jresult ;
59071   int result;
59072
59073   {
59074     try {
59075       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
59076     } catch (std::out_of_range& e) {
59077       {
59078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59079       };
59080     } catch (std::exception& e) {
59081       {
59082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59083       };
59084     } catch (Dali::DaliException e) {
59085       {
59086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59087       };
59088     } catch (...) {
59089       {
59090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59091       };
59092     }
59093   }
59094
59095   jresult = (int)result;
59096   return jresult;
59097 }
59098
59099
59100 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
59101   int jresult ;
59102   int result;
59103
59104   {
59105     try {
59106       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
59107     } catch (std::out_of_range& e) {
59108       {
59109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59110       };
59111     } catch (std::exception& e) {
59112       {
59113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59114       };
59115     } catch (Dali::DaliException e) {
59116       {
59117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59118       };
59119     } catch (...) {
59120       {
59121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59122       };
59123     }
59124   }
59125
59126   jresult = (int)result;
59127   return jresult;
59128 }
59129
59130
59131 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
59132   int jresult ;
59133   int result;
59134
59135   {
59136     try {
59137       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
59138     } catch (std::out_of_range& e) {
59139       {
59140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59141       };
59142     } catch (std::exception& e) {
59143       {
59144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59145       };
59146     } catch (Dali::DaliException e) {
59147       {
59148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59149       };
59150     } catch (...) {
59151       {
59152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59153       };
59154     }
59155   }
59156
59157   jresult = (int)result;
59158   return jresult;
59159 }
59160
59161
59162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
59163   int jresult ;
59164   int result;
59165
59166   {
59167     try {
59168       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
59169     } catch (std::out_of_range& e) {
59170       {
59171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59172       };
59173     } catch (std::exception& e) {
59174       {
59175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59176       };
59177     } catch (Dali::DaliException e) {
59178       {
59179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59180       };
59181     } catch (...) {
59182       {
59183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59184       };
59185     }
59186   }
59187
59188   jresult = (int)result;
59189   return jresult;
59190 }
59191
59192
59193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
59194   int jresult ;
59195   int result;
59196
59197   {
59198     try {
59199       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
59200     } catch (std::out_of_range& e) {
59201       {
59202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59203       };
59204     } catch (std::exception& e) {
59205       {
59206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59207       };
59208     } catch (Dali::DaliException e) {
59209       {
59210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59211       };
59212     } catch (...) {
59213       {
59214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59215       };
59216     }
59217   }
59218
59219   jresult = (int)result;
59220   return jresult;
59221 }
59222
59223
59224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
59225   int jresult ;
59226   int result;
59227
59228   {
59229     try {
59230       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
59231     } catch (std::out_of_range& e) {
59232       {
59233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59234       };
59235     } catch (std::exception& e) {
59236       {
59237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59238       };
59239     } catch (Dali::DaliException e) {
59240       {
59241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59242       };
59243     } catch (...) {
59244       {
59245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59246       };
59247     }
59248   }
59249
59250   jresult = (int)result;
59251   return jresult;
59252 }
59253
59254
59255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
59256   int jresult ;
59257   int result;
59258
59259   {
59260     try {
59261       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
59262     } catch (std::out_of_range& e) {
59263       {
59264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59265       };
59266     } catch (std::exception& e) {
59267       {
59268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59269       };
59270     } catch (Dali::DaliException e) {
59271       {
59272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59273       };
59274     } catch (...) {
59275       {
59276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59277       };
59278     }
59279   }
59280
59281   jresult = (int)result;
59282   return jresult;
59283 }
59284
59285
59286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
59287   int jresult ;
59288   int result;
59289
59290   {
59291     try {
59292       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
59293     } catch (std::out_of_range& e) {
59294       {
59295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59296       };
59297     } catch (std::exception& e) {
59298       {
59299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59300       };
59301     } catch (Dali::DaliException e) {
59302       {
59303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59304       };
59305     } catch (...) {
59306       {
59307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59308       };
59309     }
59310   }
59311
59312   jresult = (int)result;
59313   return jresult;
59314 }
59315
59316
59317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
59318   int jresult ;
59319   int result;
59320
59321   {
59322     try {
59323       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
59324     } catch (std::out_of_range& e) {
59325       {
59326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59327       };
59328     } catch (std::exception& e) {
59329       {
59330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59331       };
59332     } catch (Dali::DaliException e) {
59333       {
59334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59335       };
59336     } catch (...) {
59337       {
59338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59339       };
59340     }
59341   }
59342
59343   jresult = (int)result;
59344   return jresult;
59345 }
59346
59347
59348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
59349   int jresult ;
59350   int result;
59351
59352   {
59353     try {
59354       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
59355     } catch (std::out_of_range& e) {
59356       {
59357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59358       };
59359     } catch (std::exception& e) {
59360       {
59361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59362       };
59363     } catch (Dali::DaliException e) {
59364       {
59365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59366       };
59367     } catch (...) {
59368       {
59369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59370       };
59371     }
59372   }
59373
59374   jresult = (int)result;
59375   return jresult;
59376 }
59377
59378
59379 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
59380   int jresult ;
59381   int result;
59382
59383   {
59384     try {
59385       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
59386     } catch (std::out_of_range& e) {
59387       {
59388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59389       };
59390     } catch (std::exception& e) {
59391       {
59392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59393       };
59394     } catch (Dali::DaliException e) {
59395       {
59396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59397       };
59398     } catch (...) {
59399       {
59400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59401       };
59402     }
59403   }
59404
59405   jresult = (int)result;
59406   return jresult;
59407 }
59408
59409
59410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
59411   int jresult ;
59412   int result;
59413
59414   {
59415     try {
59416       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
59417     } catch (std::out_of_range& e) {
59418       {
59419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59420       };
59421     } catch (std::exception& e) {
59422       {
59423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59424       };
59425     } catch (Dali::DaliException e) {
59426       {
59427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59428       };
59429     } catch (...) {
59430       {
59431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59432       };
59433     }
59434   }
59435
59436   jresult = (int)result;
59437   return jresult;
59438 }
59439
59440
59441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
59442   int jresult ;
59443   int result;
59444
59445   {
59446     try {
59447       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
59448     } catch (std::out_of_range& e) {
59449       {
59450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59451       };
59452     } catch (std::exception& e) {
59453       {
59454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59455       };
59456     } catch (Dali::DaliException e) {
59457       {
59458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59459       };
59460     } catch (...) {
59461       {
59462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59463       };
59464     }
59465   }
59466
59467   jresult = (int)result;
59468   return jresult;
59469 }
59470
59471
59472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
59473   int jresult ;
59474   int result;
59475
59476   {
59477     try {
59478       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
59479     } catch (std::out_of_range& e) {
59480       {
59481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59482       };
59483     } catch (std::exception& e) {
59484       {
59485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59486       };
59487     } catch (Dali::DaliException e) {
59488       {
59489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59490       };
59491     } catch (...) {
59492       {
59493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59494       };
59495     }
59496   }
59497
59498   jresult = (int)result;
59499   return jresult;
59500 }
59501
59502
59503 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
59504   int jresult ;
59505   int result;
59506
59507   {
59508     try {
59509       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
59510     } catch (std::out_of_range& e) {
59511       {
59512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59513       };
59514     } catch (std::exception& e) {
59515       {
59516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59517       };
59518     } catch (Dali::DaliException e) {
59519       {
59520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59521       };
59522     } catch (...) {
59523       {
59524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59525       };
59526     }
59527   }
59528
59529   jresult = (int)result;
59530   return jresult;
59531 }
59532
59533
59534 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
59535   int jresult ;
59536   int result;
59537
59538   {
59539     try {
59540       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
59541     } catch (std::out_of_range& e) {
59542       {
59543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59544       };
59545     } catch (std::exception& e) {
59546       {
59547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59548       };
59549     } catch (Dali::DaliException e) {
59550       {
59551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59552       };
59553     } catch (...) {
59554       {
59555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59556       };
59557     }
59558   }
59559
59560   jresult = (int)result;
59561   return jresult;
59562 }
59563
59564
59565 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
59566   int jresult ;
59567   int result;
59568
59569   {
59570     try {
59571       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
59572     } catch (std::out_of_range& e) {
59573       {
59574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59575       };
59576     } catch (std::exception& e) {
59577       {
59578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59579       };
59580     } catch (Dali::DaliException e) {
59581       {
59582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59583       };
59584     } catch (...) {
59585       {
59586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59587       };
59588     }
59589   }
59590
59591   jresult = (int)result;
59592   return jresult;
59593 }
59594
59595
59596 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
59597   int jresult ;
59598   int result;
59599
59600   {
59601     try {
59602       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
59603     } catch (std::out_of_range& e) {
59604       {
59605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59606       };
59607     } catch (std::exception& e) {
59608       {
59609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59610       };
59611     } catch (Dali::DaliException e) {
59612       {
59613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59614       };
59615     } catch (...) {
59616       {
59617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59618       };
59619     }
59620   }
59621
59622   jresult = (int)result;
59623   return jresult;
59624 }
59625
59626
59627 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
59628   int jresult ;
59629   int result;
59630
59631   {
59632     try {
59633       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
59634     } catch (std::out_of_range& e) {
59635       {
59636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59637       };
59638     } catch (std::exception& e) {
59639       {
59640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59641       };
59642     } catch (Dali::DaliException e) {
59643       {
59644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59645       };
59646     } catch (...) {
59647       {
59648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59649       };
59650     }
59651   }
59652
59653   jresult = (int)result;
59654   return jresult;
59655 }
59656
59657
59658 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
59659   int jresult ;
59660   int result;
59661
59662   {
59663     try {
59664       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
59665     } catch (std::out_of_range& e) {
59666       {
59667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59668       };
59669     } catch (std::exception& e) {
59670       {
59671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59672       };
59673     } catch (Dali::DaliException e) {
59674       {
59675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59676       };
59677     } catch (...) {
59678       {
59679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59680       };
59681     }
59682   }
59683
59684   jresult = (int)result;
59685   return jresult;
59686 }
59687
59688
59689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
59690   int jresult ;
59691   int result;
59692
59693   {
59694     try {
59695       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
59696     } catch (std::out_of_range& e) {
59697       {
59698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59699       };
59700     } catch (std::exception& e) {
59701       {
59702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59703       };
59704     } catch (Dali::DaliException e) {
59705       {
59706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59707       };
59708     } catch (...) {
59709       {
59710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59711       };
59712     }
59713   }
59714
59715   jresult = (int)result;
59716   return jresult;
59717 }
59718
59719
59720 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
59721   int jresult ;
59722   int result;
59723
59724   {
59725     try {
59726       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
59727     } catch (std::out_of_range& e) {
59728       {
59729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59730       };
59731     } catch (std::exception& e) {
59732       {
59733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59734       };
59735     } catch (Dali::DaliException e) {
59736       {
59737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59738       };
59739     } catch (...) {
59740       {
59741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59742       };
59743     }
59744   }
59745
59746   jresult = (int)result;
59747   return jresult;
59748 }
59749
59750
59751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
59752   int jresult ;
59753   int result;
59754
59755   {
59756     try {
59757       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
59758     } catch (std::out_of_range& e) {
59759       {
59760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59761       };
59762     } catch (std::exception& e) {
59763       {
59764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59765       };
59766     } catch (Dali::DaliException e) {
59767       {
59768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59769       };
59770     } catch (...) {
59771       {
59772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59773       };
59774     }
59775   }
59776
59777   jresult = (int)result;
59778   return jresult;
59779 }
59780
59781
59782 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
59783   int jresult ;
59784   int result;
59785
59786   {
59787     try {
59788       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
59789     } catch (std::out_of_range& e) {
59790       {
59791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59792       };
59793     } catch (std::exception& e) {
59794       {
59795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59796       };
59797     } catch (Dali::DaliException e) {
59798       {
59799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59800       };
59801     } catch (...) {
59802       {
59803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59804       };
59805     }
59806   }
59807
59808   jresult = (int)result;
59809   return jresult;
59810 }
59811
59812
59813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
59814   int jresult ;
59815   int result;
59816
59817   {
59818     try {
59819       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
59820     } catch (std::out_of_range& e) {
59821       {
59822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59823       };
59824     } catch (std::exception& e) {
59825       {
59826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59827       };
59828     } catch (Dali::DaliException e) {
59829       {
59830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59831       };
59832     } catch (...) {
59833       {
59834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59835       };
59836     }
59837   }
59838
59839   jresult = (int)result;
59840   return jresult;
59841 }
59842
59843
59844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
59845   int jresult ;
59846   int result;
59847
59848   {
59849     try {
59850       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
59851     } catch (std::out_of_range& e) {
59852       {
59853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59854       };
59855     } catch (std::exception& e) {
59856       {
59857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59858       };
59859     } catch (Dali::DaliException e) {
59860       {
59861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59862       };
59863     } catch (...) {
59864       {
59865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59866       };
59867     }
59868   }
59869
59870   jresult = (int)result;
59871   return jresult;
59872 }
59873
59874
59875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
59876   void * jresult ;
59877   Dali::Toolkit::Builder *result = 0 ;
59878
59879   {
59880     try {
59881       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
59882     } catch (std::out_of_range& e) {
59883       {
59884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59885       };
59886     } catch (std::exception& e) {
59887       {
59888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59889       };
59890     } catch (Dali::DaliException e) {
59891       {
59892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59893       };
59894     } catch (...) {
59895       {
59896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59897       };
59898     }
59899   }
59900
59901   jresult = (void *)result;
59902   return jresult;
59903 }
59904
59905
59906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
59907   void * jresult ;
59908   Dali::Toolkit::Builder result;
59909
59910   {
59911     try {
59912       result = Dali::Toolkit::Builder::New();
59913     } catch (std::out_of_range& e) {
59914       {
59915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59916       };
59917     } catch (std::exception& e) {
59918       {
59919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59920       };
59921     } catch (Dali::DaliException e) {
59922       {
59923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59924       };
59925     } catch (...) {
59926       {
59927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59928       };
59929     }
59930   }
59931
59932   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
59933   return jresult;
59934 }
59935
59936
59937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
59938   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59939
59940   arg1 = (Dali::Toolkit::Builder *)jarg1;
59941   {
59942     try {
59943       delete arg1;
59944     } catch (std::out_of_range& e) {
59945       {
59946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59947       };
59948     } catch (std::exception& e) {
59949       {
59950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59951       };
59952     } catch (Dali::DaliException e) {
59953       {
59954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59955       };
59956     } catch (...) {
59957       {
59958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59959       };
59960     }
59961   }
59962
59963 }
59964
59965
59966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
59967   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
59968   std::string *arg2 = 0 ;
59969   Dali::Toolkit::Builder::UIFormat arg3 ;
59970
59971   arg1 = (Dali::Toolkit::Builder *)jarg1;
59972   if (!jarg2) {
59973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59974     return ;
59975   }
59976   std::string arg2_str(jarg2);
59977   arg2 = &arg2_str;
59978   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
59979   {
59980     try {
59981       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
59982     } catch (std::out_of_range& e) {
59983       {
59984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59985       };
59986     } catch (std::exception& e) {
59987       {
59988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59989       };
59990     } catch (Dali::DaliException e) {
59991       {
59992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59993       };
59994     } catch (...) {
59995       {
59996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59997       };
59998     }
59999   }
60000
60001
60002   //argout typemap for const std::string&
60003
60004 }
60005
60006
60007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
60008   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60009   std::string *arg2 = 0 ;
60010
60011   arg1 = (Dali::Toolkit::Builder *)jarg1;
60012   if (!jarg2) {
60013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60014     return ;
60015   }
60016   std::string arg2_str(jarg2);
60017   arg2 = &arg2_str;
60018   {
60019     try {
60020       (arg1)->LoadFromString((std::string const &)*arg2);
60021     } catch (std::out_of_range& e) {
60022       {
60023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60024       };
60025     } catch (std::exception& e) {
60026       {
60027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60028       };
60029     } catch (Dali::DaliException e) {
60030       {
60031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60032       };
60033     } catch (...) {
60034       {
60035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60036       };
60037     }
60038   }
60039
60040
60041   //argout typemap for const std::string&
60042
60043 }
60044
60045
60046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
60047   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60048   Dali::Property::Map *arg2 = 0 ;
60049
60050   arg1 = (Dali::Toolkit::Builder *)jarg1;
60051   arg2 = (Dali::Property::Map *)jarg2;
60052   if (!arg2) {
60053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60054     return ;
60055   }
60056   {
60057     try {
60058       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
60059     } catch (std::out_of_range& e) {
60060       {
60061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60062       };
60063     } catch (std::exception& e) {
60064       {
60065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60066       };
60067     } catch (Dali::DaliException e) {
60068       {
60069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60070       };
60071     } catch (...) {
60072       {
60073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60074       };
60075     }
60076   }
60077
60078 }
60079
60080
60081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
60082   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60083   std::string *arg2 = 0 ;
60084   Dali::Property::Value *arg3 = 0 ;
60085
60086   arg1 = (Dali::Toolkit::Builder *)jarg1;
60087   if (!jarg2) {
60088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60089     return ;
60090   }
60091   std::string arg2_str(jarg2);
60092   arg2 = &arg2_str;
60093   arg3 = (Dali::Property::Value *)jarg3;
60094   if (!arg3) {
60095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
60096     return ;
60097   }
60098   {
60099     try {
60100       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
60101     } catch (std::out_of_range& e) {
60102       {
60103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60104       };
60105     } catch (std::exception& e) {
60106       {
60107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60108       };
60109     } catch (Dali::DaliException e) {
60110       {
60111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60112       };
60113     } catch (...) {
60114       {
60115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60116       };
60117     }
60118   }
60119
60120
60121   //argout typemap for const std::string&
60122
60123 }
60124
60125
60126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
60127   void * jresult ;
60128   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60129   Dali::Property::Map *result = 0 ;
60130
60131   arg1 = (Dali::Toolkit::Builder *)jarg1;
60132   {
60133     try {
60134       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
60135     } catch (std::out_of_range& e) {
60136       {
60137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60138       };
60139     } catch (std::exception& e) {
60140       {
60141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60142       };
60143     } catch (Dali::DaliException e) {
60144       {
60145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60146       };
60147     } catch (...) {
60148       {
60149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60150       };
60151     }
60152   }
60153
60154   jresult = (void *)result;
60155   return jresult;
60156 }
60157
60158
60159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
60160   void * jresult ;
60161   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60162   std::string *arg2 = 0 ;
60163   Dali::Property::Value *result = 0 ;
60164
60165   arg1 = (Dali::Toolkit::Builder *)jarg1;
60166   if (!jarg2) {
60167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60168     return 0;
60169   }
60170   std::string arg2_str(jarg2);
60171   arg2 = &arg2_str;
60172   {
60173     try {
60174       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
60175     } catch (std::out_of_range& e) {
60176       {
60177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60178       };
60179     } catch (std::exception& e) {
60180       {
60181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60182       };
60183     } catch (Dali::DaliException e) {
60184       {
60185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60186       };
60187     } catch (...) {
60188       {
60189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60190       };
60191     }
60192   }
60193
60194   jresult = (void *)result;
60195
60196   //argout typemap for const std::string&
60197
60198   return jresult;
60199 }
60200
60201
60202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
60203   void * jresult ;
60204   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60205   std::string *arg2 = 0 ;
60206   Dali::Animation result;
60207
60208   arg1 = (Dali::Toolkit::Builder *)jarg1;
60209   if (!jarg2) {
60210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60211     return 0;
60212   }
60213   std::string arg2_str(jarg2);
60214   arg2 = &arg2_str;
60215   {
60216     try {
60217       result = (arg1)->CreateAnimation((std::string const &)*arg2);
60218     } catch (std::out_of_range& e) {
60219       {
60220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60221       };
60222     } catch (std::exception& e) {
60223       {
60224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60225       };
60226     } catch (Dali::DaliException e) {
60227       {
60228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60229       };
60230     } catch (...) {
60231       {
60232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60233       };
60234     }
60235   }
60236
60237   jresult = new Dali::Animation((const Dali::Animation &)result);
60238
60239   //argout typemap for const std::string&
60240
60241   return jresult;
60242 }
60243
60244
60245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
60246   void * jresult ;
60247   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60248   std::string *arg2 = 0 ;
60249   Dali::Property::Map *arg3 = 0 ;
60250   Dali::Animation result;
60251
60252   arg1 = (Dali::Toolkit::Builder *)jarg1;
60253   if (!jarg2) {
60254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60255     return 0;
60256   }
60257   std::string arg2_str(jarg2);
60258   arg2 = &arg2_str;
60259   arg3 = (Dali::Property::Map *)jarg3;
60260   if (!arg3) {
60261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60262     return 0;
60263   }
60264   {
60265     try {
60266       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
60267     } catch (std::out_of_range& e) {
60268       {
60269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60270       };
60271     } catch (std::exception& e) {
60272       {
60273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60274       };
60275     } catch (Dali::DaliException e) {
60276       {
60277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60278       };
60279     } catch (...) {
60280       {
60281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60282       };
60283     }
60284   }
60285
60286   jresult = new Dali::Animation((const Dali::Animation &)result);
60287
60288   //argout typemap for const std::string&
60289
60290   return jresult;
60291 }
60292
60293
60294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
60295   void * jresult ;
60296   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60297   std::string *arg2 = 0 ;
60298   Dali::Actor arg3 ;
60299   Dali::Actor *argp3 ;
60300   Dali::Animation result;
60301
60302   arg1 = (Dali::Toolkit::Builder *)jarg1;
60303   if (!jarg2) {
60304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60305     return 0;
60306   }
60307   std::string arg2_str(jarg2);
60308   arg2 = &arg2_str;
60309   argp3 = (Dali::Actor *)jarg3;
60310   if (!argp3) {
60311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60312     return 0;
60313   }
60314   arg3 = *argp3;
60315   {
60316     try {
60317       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
60318     } catch (std::out_of_range& e) {
60319       {
60320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60321       };
60322     } catch (std::exception& e) {
60323       {
60324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60325       };
60326     } catch (Dali::DaliException e) {
60327       {
60328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60329       };
60330     } catch (...) {
60331       {
60332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60333       };
60334     }
60335   }
60336
60337   jresult = new Dali::Animation((const Dali::Animation &)result);
60338
60339   //argout typemap for const std::string&
60340
60341   return jresult;
60342 }
60343
60344
60345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
60346   void * jresult ;
60347   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60348   std::string *arg2 = 0 ;
60349   Dali::Property::Map *arg3 = 0 ;
60350   Dali::Actor arg4 ;
60351   Dali::Actor *argp4 ;
60352   Dali::Animation result;
60353
60354   arg1 = (Dali::Toolkit::Builder *)jarg1;
60355   if (!jarg2) {
60356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60357     return 0;
60358   }
60359   std::string arg2_str(jarg2);
60360   arg2 = &arg2_str;
60361   arg3 = (Dali::Property::Map *)jarg3;
60362   if (!arg3) {
60363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60364     return 0;
60365   }
60366   argp4 = (Dali::Actor *)jarg4;
60367   if (!argp4) {
60368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60369     return 0;
60370   }
60371   arg4 = *argp4;
60372   {
60373     try {
60374       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
60375     } catch (std::out_of_range& e) {
60376       {
60377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60378       };
60379     } catch (std::exception& e) {
60380       {
60381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60382       };
60383     } catch (Dali::DaliException e) {
60384       {
60385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60386       };
60387     } catch (...) {
60388       {
60389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60390       };
60391     }
60392   }
60393
60394   jresult = new Dali::Animation((const Dali::Animation &)result);
60395
60396   //argout typemap for const std::string&
60397
60398   return jresult;
60399 }
60400
60401
60402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
60403   void * jresult ;
60404   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60405   std::string *arg2 = 0 ;
60406   Dali::BaseHandle result;
60407
60408   arg1 = (Dali::Toolkit::Builder *)jarg1;
60409   if (!jarg2) {
60410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60411     return 0;
60412   }
60413   std::string arg2_str(jarg2);
60414   arg2 = &arg2_str;
60415   {
60416     try {
60417       result = (arg1)->Create((std::string const &)*arg2);
60418     } catch (std::out_of_range& e) {
60419       {
60420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60421       };
60422     } catch (std::exception& e) {
60423       {
60424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60425       };
60426     } catch (Dali::DaliException e) {
60427       {
60428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60429       };
60430     } catch (...) {
60431       {
60432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60433       };
60434     }
60435   }
60436
60437   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
60438
60439   //argout typemap for const std::string&
60440
60441   return jresult;
60442 }
60443
60444
60445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
60446   void * jresult ;
60447   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60448   std::string *arg2 = 0 ;
60449   Dali::Property::Map *arg3 = 0 ;
60450   Dali::BaseHandle result;
60451
60452   arg1 = (Dali::Toolkit::Builder *)jarg1;
60453   if (!jarg2) {
60454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60455     return 0;
60456   }
60457   std::string arg2_str(jarg2);
60458   arg2 = &arg2_str;
60459   arg3 = (Dali::Property::Map *)jarg3;
60460   if (!arg3) {
60461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60462     return 0;
60463   }
60464   {
60465     try {
60466       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
60467     } catch (std::out_of_range& e) {
60468       {
60469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60470       };
60471     } catch (std::exception& e) {
60472       {
60473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60474       };
60475     } catch (Dali::DaliException e) {
60476       {
60477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60478       };
60479     } catch (...) {
60480       {
60481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60482       };
60483     }
60484   }
60485
60486   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
60487
60488   //argout typemap for const std::string&
60489
60490   return jresult;
60491 }
60492
60493
60494 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
60495   void * jresult ;
60496   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60497   std::string *arg2 = 0 ;
60498   Dali::BaseHandle result;
60499
60500   arg1 = (Dali::Toolkit::Builder *)jarg1;
60501   if (!jarg2) {
60502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60503     return 0;
60504   }
60505   std::string arg2_str(jarg2);
60506   arg2 = &arg2_str;
60507   {
60508     try {
60509       result = (arg1)->CreateFromJson((std::string const &)*arg2);
60510     } catch (std::out_of_range& e) {
60511       {
60512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60513       };
60514     } catch (std::exception& e) {
60515       {
60516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60517       };
60518     } catch (Dali::DaliException e) {
60519       {
60520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60521       };
60522     } catch (...) {
60523       {
60524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60525       };
60526     }
60527   }
60528
60529   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
60530
60531   //argout typemap for const std::string&
60532
60533   return jresult;
60534 }
60535
60536
60537 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
60538   unsigned int jresult ;
60539   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60540   std::string *arg2 = 0 ;
60541   Dali::Handle *arg3 = 0 ;
60542   bool result;
60543
60544   arg1 = (Dali::Toolkit::Builder *)jarg1;
60545   if (!jarg2) {
60546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60547     return 0;
60548   }
60549   std::string arg2_str(jarg2);
60550   arg2 = &arg2_str;
60551   arg3 = (Dali::Handle *)jarg3;
60552   if (!arg3) {
60553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
60554     return 0;
60555   }
60556   {
60557     try {
60558       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
60559     } catch (std::out_of_range& e) {
60560       {
60561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60562       };
60563     } catch (std::exception& e) {
60564       {
60565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60566       };
60567     } catch (Dali::DaliException e) {
60568       {
60569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60570       };
60571     } catch (...) {
60572       {
60573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60574       };
60575     }
60576   }
60577
60578   jresult = result;
60579
60580   //argout typemap for const std::string&
60581
60582   return jresult;
60583 }
60584
60585
60586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
60587   unsigned int jresult ;
60588   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60589   Dali::Handle *arg2 = 0 ;
60590   std::string *arg3 = 0 ;
60591   bool result;
60592
60593   arg1 = (Dali::Toolkit::Builder *)jarg1;
60594   arg2 = (Dali::Handle *)jarg2;
60595   if (!arg2) {
60596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
60597     return 0;
60598   }
60599   if (!jarg3) {
60600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60601     return 0;
60602   }
60603   std::string arg3_str(jarg3);
60604   arg3 = &arg3_str;
60605   {
60606     try {
60607       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
60608     } catch (std::out_of_range& e) {
60609       {
60610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60611       };
60612     } catch (std::exception& e) {
60613       {
60614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60615       };
60616     } catch (Dali::DaliException e) {
60617       {
60618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60619       };
60620     } catch (...) {
60621       {
60622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60623       };
60624     }
60625   }
60626
60627   jresult = result;
60628
60629   //argout typemap for const std::string&
60630
60631   return jresult;
60632 }
60633
60634
60635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
60636   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60637   Dali::Actor arg2 ;
60638   Dali::Actor *argp2 ;
60639
60640   arg1 = (Dali::Toolkit::Builder *)jarg1;
60641   argp2 = (Dali::Actor *)jarg2;
60642   if (!argp2) {
60643     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60644     return ;
60645   }
60646   arg2 = *argp2;
60647   {
60648     try {
60649       (arg1)->AddActors(arg2);
60650     } catch (std::out_of_range& e) {
60651       {
60652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60653       };
60654     } catch (std::exception& e) {
60655       {
60656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60657       };
60658     } catch (Dali::DaliException e) {
60659       {
60660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60661       };
60662     } catch (...) {
60663       {
60664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60665       };
60666     }
60667   }
60668
60669 }
60670
60671
60672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
60673   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60674   std::string *arg2 = 0 ;
60675   Dali::Actor arg3 ;
60676   Dali::Actor *argp3 ;
60677
60678   arg1 = (Dali::Toolkit::Builder *)jarg1;
60679   if (!jarg2) {
60680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60681     return ;
60682   }
60683   std::string arg2_str(jarg2);
60684   arg2 = &arg2_str;
60685   argp3 = (Dali::Actor *)jarg3;
60686   if (!argp3) {
60687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
60688     return ;
60689   }
60690   arg3 = *argp3;
60691   {
60692     try {
60693       (arg1)->AddActors((std::string const &)*arg2,arg3);
60694     } catch (std::out_of_range& e) {
60695       {
60696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60697       };
60698     } catch (std::exception& e) {
60699       {
60700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60701       };
60702     } catch (Dali::DaliException e) {
60703       {
60704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60705       };
60706     } catch (...) {
60707       {
60708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60709       };
60710     }
60711   }
60712
60713
60714   //argout typemap for const std::string&
60715
60716 }
60717
60718
60719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
60720   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60721   std::string *arg2 = 0 ;
60722
60723   arg1 = (Dali::Toolkit::Builder *)jarg1;
60724   if (!jarg2) {
60725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60726     return ;
60727   }
60728   std::string arg2_str(jarg2);
60729   arg2 = &arg2_str;
60730   {
60731     try {
60732       (arg1)->CreateRenderTask((std::string const &)*arg2);
60733     } catch (std::out_of_range& e) {
60734       {
60735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60736       };
60737     } catch (std::exception& e) {
60738       {
60739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60740       };
60741     } catch (Dali::DaliException e) {
60742       {
60743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60744       };
60745     } catch (...) {
60746       {
60747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60748       };
60749     }
60750   }
60751
60752
60753   //argout typemap for const std::string&
60754
60755 }
60756
60757
60758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
60759   void * jresult ;
60760   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60761   std::string *arg2 = 0 ;
60762   Dali::Path result;
60763
60764   arg1 = (Dali::Toolkit::Builder *)jarg1;
60765   if (!jarg2) {
60766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60767     return 0;
60768   }
60769   std::string arg2_str(jarg2);
60770   arg2 = &arg2_str;
60771   {
60772     try {
60773       result = (arg1)->GetPath((std::string const &)*arg2);
60774     } catch (std::out_of_range& e) {
60775       {
60776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60777       };
60778     } catch (std::exception& e) {
60779       {
60780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60781       };
60782     } catch (Dali::DaliException e) {
60783       {
60784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60785       };
60786     } catch (...) {
60787       {
60788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60789       };
60790     }
60791   }
60792
60793   jresult = new Dali::Path((const Dali::Path &)result);
60794
60795   //argout typemap for const std::string&
60796
60797   return jresult;
60798 }
60799
60800
60801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
60802   void * jresult ;
60803   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60804   std::string *arg2 = 0 ;
60805   Dali::PathConstrainer result;
60806
60807   arg1 = (Dali::Toolkit::Builder *)jarg1;
60808   if (!jarg2) {
60809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60810     return 0;
60811   }
60812   std::string arg2_str(jarg2);
60813   arg2 = &arg2_str;
60814   {
60815     try {
60816       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
60817     } catch (std::out_of_range& e) {
60818       {
60819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60820       };
60821     } catch (std::exception& e) {
60822       {
60823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60824       };
60825     } catch (Dali::DaliException e) {
60826       {
60827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60828       };
60829     } catch (...) {
60830       {
60831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60832       };
60833     }
60834   }
60835
60836   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
60837
60838   //argout typemap for const std::string&
60839
60840   return jresult;
60841 }
60842
60843
60844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
60845   void * jresult ;
60846   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60847   std::string *arg2 = 0 ;
60848   Dali::LinearConstrainer result;
60849
60850   arg1 = (Dali::Toolkit::Builder *)jarg1;
60851   if (!jarg2) {
60852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
60853     return 0;
60854   }
60855   std::string arg2_str(jarg2);
60856   arg2 = &arg2_str;
60857   {
60858     try {
60859       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
60860     } catch (std::out_of_range& e) {
60861       {
60862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60863       };
60864     } catch (std::exception& e) {
60865       {
60866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60867       };
60868     } catch (Dali::DaliException e) {
60869       {
60870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60871       };
60872     } catch (...) {
60873       {
60874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60875       };
60876     }
60877   }
60878
60879   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
60880
60881   //argout typemap for const std::string&
60882
60883   return jresult;
60884 }
60885
60886
60887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
60888   void * jresult ;
60889   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
60890   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
60891
60892   arg1 = (Dali::Toolkit::Builder *)jarg1;
60893   {
60894     try {
60895       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
60896     } catch (std::out_of_range& e) {
60897       {
60898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60899       };
60900     } catch (std::exception& e) {
60901       {
60902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60903       };
60904     } catch (Dali::DaliException e) {
60905       {
60906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60907       };
60908     } catch (...) {
60909       {
60910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60911       };
60912     }
60913   }
60914
60915   jresult = (void *)result;
60916   return jresult;
60917 }
60918
60919
60920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
60921   void * jresult ;
60922   Dali::Toolkit::TransitionData *result = 0 ;
60923
60924   {
60925     try {
60926       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
60927     } catch (std::out_of_range& e) {
60928       {
60929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60930       };
60931     } catch (std::exception& e) {
60932       {
60933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60934       };
60935     } catch (Dali::DaliException e) {
60936       {
60937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60938       };
60939     } catch (...) {
60940       {
60941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60942       };
60943     }
60944   }
60945
60946   jresult = (void *)result;
60947   return jresult;
60948 }
60949
60950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
60951   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
60952
60953   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
60954   {
60955     try {
60956       delete arg1;
60957     } catch (std::out_of_range& e) {
60958       {
60959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60960       };
60961     } catch (std::exception& e) {
60962       {
60963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60964       };
60965     } catch (Dali::DaliException e) {
60966       {
60967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60968       };
60969     } catch (...) {
60970       {
60971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60972       };
60973     }
60974   }
60975
60976 }
60977
60978
60979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
60980   void * jresult ;
60981   Dali::Property::Map *arg1 = 0 ;
60982   Dali::Toolkit::TransitionData result;
60983
60984   arg1 = (Dali::Property::Map *)jarg1;
60985   if (!arg1) {
60986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
60987     return 0;
60988   }
60989   {
60990     try {
60991       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
60992     } catch (std::out_of_range& e) {
60993       {
60994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60995       };
60996     } catch (std::exception& e) {
60997       {
60998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60999       };
61000     } catch (Dali::DaliException e) {
61001       {
61002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61003       };
61004     } catch (...) {
61005       {
61006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61007       };
61008     }
61009   }
61010
61011   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
61012   return jresult;
61013 }
61014
61015
61016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
61017   void * jresult ;
61018   Dali::Property::Array *arg1 = 0 ;
61019   Dali::Toolkit::TransitionData result;
61020
61021   arg1 = (Dali::Property::Array *)jarg1;
61022   if (!arg1) {
61023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
61024     return 0;
61025   }
61026   {
61027     try {
61028       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
61029     } catch (std::out_of_range& e) {
61030       {
61031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61032       };
61033     } catch (std::exception& e) {
61034       {
61035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61036       };
61037     } catch (Dali::DaliException e) {
61038       {
61039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61040       };
61041     } catch (...) {
61042       {
61043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61044       };
61045     }
61046   }
61047
61048   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
61049   return jresult;
61050 }
61051
61052
61053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
61054   void * jresult ;
61055   Dali::BaseHandle arg1 ;
61056   Dali::BaseHandle *argp1 ;
61057   Dali::Toolkit::TransitionData result;
61058
61059   argp1 = (Dali::BaseHandle *)jarg1;
61060   if (!argp1) {
61061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
61062     return 0;
61063   }
61064   arg1 = *argp1;
61065   {
61066     try {
61067       result = Dali::Toolkit::TransitionData::DownCast(arg1);
61068     } catch (std::out_of_range& e) {
61069       {
61070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61071       };
61072     } catch (std::exception& e) {
61073       {
61074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61075       };
61076     } catch (Dali::DaliException e) {
61077       {
61078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61079       };
61080     } catch (...) {
61081       {
61082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61083       };
61084     }
61085   }
61086
61087   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
61088   return jresult;
61089 }
61090
61091
61092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
61093   void * jresult ;
61094   Dali::Toolkit::TransitionData *arg1 = 0 ;
61095   Dali::Toolkit::TransitionData *result = 0 ;
61096
61097   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
61098   if (!arg1) {
61099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
61100     return 0;
61101   }
61102   {
61103     try {
61104       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
61105     } catch (std::out_of_range& e) {
61106       {
61107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61108       };
61109     } catch (std::exception& e) {
61110       {
61111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61112       };
61113     } catch (Dali::DaliException e) {
61114       {
61115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61116       };
61117     } catch (...) {
61118       {
61119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61120       };
61121     }
61122   }
61123
61124   jresult = (void *)result;
61125   return jresult;
61126 }
61127
61128
61129 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
61130   void * jresult ;
61131   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
61132   Dali::Toolkit::TransitionData *arg2 = 0 ;
61133   Dali::Toolkit::TransitionData *result = 0 ;
61134
61135   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
61136   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
61137   if (!arg2) {
61138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
61139     return 0;
61140   }
61141   {
61142     try {
61143       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
61144     } catch (std::out_of_range& e) {
61145       {
61146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61147       };
61148     } catch (std::exception& e) {
61149       {
61150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61151       };
61152     } catch (Dali::DaliException e) {
61153       {
61154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61155       };
61156     } catch (...) {
61157       {
61158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61159       };
61160     }
61161   }
61162
61163   jresult = (void *)result;
61164   return jresult;
61165 }
61166
61167
61168 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
61169   unsigned long jresult ;
61170   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
61171   size_t result;
61172
61173   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
61174   {
61175     try {
61176       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
61177     } catch (std::out_of_range& e) {
61178       {
61179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61180       };
61181     } catch (std::exception& e) {
61182       {
61183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61184       };
61185     } catch (Dali::DaliException e) {
61186       {
61187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61188       };
61189     } catch (...) {
61190       {
61191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61192       };
61193     }
61194   }
61195
61196   jresult = (unsigned long)result;
61197   return jresult;
61198 }
61199
61200
61201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
61202   void * jresult ;
61203   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
61204   size_t arg2 ;
61205   Dali::Property::Map result;
61206
61207   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
61208   arg2 = (size_t)jarg2;
61209   {
61210     try {
61211       result = (arg1)->GetAnimatorAt(arg2);
61212     } catch (std::out_of_range& e) {
61213       {
61214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61215       };
61216     } catch (std::exception& e) {
61217       {
61218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61219       };
61220     } catch (Dali::DaliException e) {
61221       {
61222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61223       };
61224     } catch (...) {
61225       {
61226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61227       };
61228     }
61229   }
61230
61231   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
61232   return jresult;
61233 }
61234
61235
61236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
61237   int jresult ;
61238   int result;
61239
61240   {
61241     try {
61242       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
61243     } catch (std::out_of_range& e) {
61244       {
61245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61246       };
61247     } catch (std::exception& e) {
61248       {
61249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61250       };
61251     } catch (Dali::DaliException e) {
61252       {
61253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61254       };
61255     } catch (...) {
61256       {
61257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61258       };
61259     }
61260   }
61261
61262   jresult = (int)result;
61263   return jresult;
61264 }
61265
61266
61267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
61268   int jresult ;
61269   int result;
61270
61271   {
61272     try {
61273       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
61274     } catch (std::out_of_range& e) {
61275       {
61276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61277       };
61278     } catch (std::exception& e) {
61279       {
61280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61281       };
61282     } catch (Dali::DaliException e) {
61283       {
61284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61285       };
61286     } catch (...) {
61287       {
61288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61289       };
61290     }
61291   }
61292
61293   jresult = (int)result;
61294   return jresult;
61295 }
61296
61297
61298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
61299   int jresult ;
61300   int result;
61301
61302   {
61303     try {
61304       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
61305     } catch (std::out_of_range& e) {
61306       {
61307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61308       };
61309     } catch (std::exception& e) {
61310       {
61311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61312       };
61313     } catch (Dali::DaliException e) {
61314       {
61315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61316       };
61317     } catch (...) {
61318       {
61319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61320       };
61321     }
61322   }
61323
61324   jresult = (int)result;
61325   return jresult;
61326 }
61327
61328
61329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
61330   int jresult ;
61331   int result;
61332
61333   {
61334     try {
61335       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
61336     } catch (std::out_of_range& e) {
61337       {
61338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61339       };
61340     } catch (std::exception& e) {
61341       {
61342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61343       };
61344     } catch (Dali::DaliException e) {
61345       {
61346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61347       };
61348     } catch (...) {
61349       {
61350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61351       };
61352     }
61353   }
61354
61355   jresult = (int)result;
61356   return jresult;
61357 }
61358
61359
61360 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
61361   int jresult ;
61362   int result;
61363
61364   {
61365     try {
61366       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
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 (Dali::DaliException e) {
61376       {
61377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61378       };
61379     } catch (...) {
61380       {
61381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61382       };
61383     }
61384   }
61385
61386   jresult = (int)result;
61387   return jresult;
61388 }
61389
61390
61391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
61392   int jresult ;
61393   int result;
61394
61395   {
61396     try {
61397       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
61398     } catch (std::out_of_range& e) {
61399       {
61400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61401       };
61402     } catch (std::exception& e) {
61403       {
61404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61405       };
61406     } catch (Dali::DaliException e) {
61407       {
61408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61409       };
61410     } catch (...) {
61411       {
61412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61413       };
61414     }
61415   }
61416
61417   jresult = (int)result;
61418   return jresult;
61419 }
61420
61421
61422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
61423   int jresult ;
61424   int result;
61425
61426   {
61427     try {
61428       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
61429     } catch (std::out_of_range& e) {
61430       {
61431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61432       };
61433     } catch (std::exception& e) {
61434       {
61435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61436       };
61437     } catch (Dali::DaliException e) {
61438       {
61439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61440       };
61441     } catch (...) {
61442       {
61443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61444       };
61445     }
61446   }
61447
61448   jresult = (int)result;
61449   return jresult;
61450 }
61451
61452
61453 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
61454   int jresult ;
61455   int result;
61456
61457   {
61458     try {
61459       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
61460     } catch (std::out_of_range& e) {
61461       {
61462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61463       };
61464     } catch (std::exception& e) {
61465       {
61466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61467       };
61468     } catch (Dali::DaliException e) {
61469       {
61470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61471       };
61472     } catch (...) {
61473       {
61474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61475       };
61476     }
61477   }
61478
61479   jresult = (int)result;
61480   return jresult;
61481 }
61482
61483
61484 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
61485   int jresult ;
61486   int result;
61487
61488   {
61489     try {
61490       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
61491     } catch (std::out_of_range& e) {
61492       {
61493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61494       };
61495     } catch (std::exception& e) {
61496       {
61497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61498       };
61499     } catch (Dali::DaliException e) {
61500       {
61501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61502       };
61503     } catch (...) {
61504       {
61505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61506       };
61507     }
61508   }
61509
61510   jresult = (int)result;
61511   return jresult;
61512 }
61513
61514
61515 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
61516   int jresult ;
61517   int result;
61518
61519   {
61520     try {
61521       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
61522     } catch (std::out_of_range& e) {
61523       {
61524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61525       };
61526     } catch (std::exception& e) {
61527       {
61528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61529       };
61530     } catch (Dali::DaliException e) {
61531       {
61532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61533       };
61534     } catch (...) {
61535       {
61536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61537       };
61538     }
61539   }
61540
61541   jresult = (int)result;
61542   return jresult;
61543 }
61544
61545
61546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
61547   int jresult ;
61548   int result;
61549
61550   {
61551     try {
61552       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
61553     } catch (std::out_of_range& e) {
61554       {
61555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61556       };
61557     } catch (std::exception& e) {
61558       {
61559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61560       };
61561     } catch (Dali::DaliException e) {
61562       {
61563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61564       };
61565     } catch (...) {
61566       {
61567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61568       };
61569     }
61570   }
61571
61572   jresult = (int)result;
61573   return jresult;
61574 }
61575
61576
61577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
61578   int jresult ;
61579   int result;
61580
61581   {
61582     try {
61583       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
61584     } catch (std::out_of_range& e) {
61585       {
61586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61587       };
61588     } catch (std::exception& e) {
61589       {
61590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61591       };
61592     } catch (Dali::DaliException e) {
61593       {
61594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61595       };
61596     } catch (...) {
61597       {
61598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61599       };
61600     }
61601   }
61602
61603   jresult = (int)result;
61604   return jresult;
61605 }
61606
61607
61608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
61609   int jresult ;
61610   int result;
61611
61612   {
61613     try {
61614       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
61615     } catch (std::out_of_range& e) {
61616       {
61617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61618       };
61619     } catch (std::exception& e) {
61620       {
61621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61622       };
61623     } catch (Dali::DaliException e) {
61624       {
61625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61626       };
61627     } catch (...) {
61628       {
61629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61630       };
61631     }
61632   }
61633
61634   jresult = (int)result;
61635   return jresult;
61636 }
61637
61638
61639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
61640   int jresult ;
61641   int result;
61642
61643   {
61644     try {
61645       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
61646     } catch (std::out_of_range& e) {
61647       {
61648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61649       };
61650     } catch (std::exception& e) {
61651       {
61652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61653       };
61654     } catch (Dali::DaliException e) {
61655       {
61656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61657       };
61658     } catch (...) {
61659       {
61660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61661       };
61662     }
61663   }
61664
61665   jresult = (int)result;
61666   return jresult;
61667 }
61668
61669
61670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
61671   void * jresult ;
61672   Dali::Toolkit::Control result;
61673
61674   {
61675     try {
61676       result = Dali::Toolkit::Internal::Control::New();
61677     } catch (std::out_of_range& e) {
61678       {
61679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61680       };
61681     } catch (std::exception& e) {
61682       {
61683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61684       };
61685     } catch (Dali::DaliException e) {
61686       {
61687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61688       };
61689     } catch (...) {
61690       {
61691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61692       };
61693     }
61694   }
61695
61696   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
61697   return jresult;
61698 }
61699
61700
61701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
61702   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61703   std::string *arg2 = 0 ;
61704
61705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61706   if (!jarg2) {
61707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
61708     return ;
61709   }
61710   std::string arg2_str(jarg2);
61711   arg2 = &arg2_str;
61712   {
61713     try {
61714       (arg1)->SetStyleName((std::string const &)*arg2);
61715     } catch (std::out_of_range& e) {
61716       {
61717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61718       };
61719     } catch (std::exception& e) {
61720       {
61721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61722       };
61723     } catch (Dali::DaliException e) {
61724       {
61725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61726       };
61727     } catch (...) {
61728       {
61729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61730       };
61731     }
61732   }
61733
61734
61735   //argout typemap for const std::string&
61736
61737 }
61738
61739
61740 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
61741   char * jresult ;
61742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61743   std::string *result = 0 ;
61744
61745   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61746   {
61747     try {
61748       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
61749     } catch (std::out_of_range& e) {
61750       {
61751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61752       };
61753     } catch (std::exception& e) {
61754       {
61755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61756       };
61757     } catch (Dali::DaliException e) {
61758       {
61759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61760       };
61761     } catch (...) {
61762       {
61763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61764       };
61765     }
61766   }
61767
61768   jresult = SWIG_csharp_string_callback(result->c_str());
61769   return jresult;
61770 }
61771
61772
61773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
61774   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61775   Dali::Vector4 *arg2 = 0 ;
61776
61777   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61778   arg2 = (Dali::Vector4 *)jarg2;
61779   if (!arg2) {
61780     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
61781     return ;
61782   }
61783   {
61784     try {
61785       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
61786     } catch (std::out_of_range& e) {
61787       {
61788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61789       };
61790     } catch (std::exception& e) {
61791       {
61792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61793       };
61794     } catch (Dali::DaliException e) {
61795       {
61796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61797       };
61798     } catch (...) {
61799       {
61800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61801       };
61802     }
61803   }
61804
61805 }
61806
61807
61808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
61809   void * jresult ;
61810   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
61811   Dali::Vector4 result;
61812
61813   arg1 = (Dali::Handle *)jarg1;
61814   {
61815     try {
61816       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
61817       if (resultMap)
61818       {
61819         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
61820         if(type && type->Get<int>() == Visual::COLOR )
61821         {
61822           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
61823           if (value)
61824           {
61825             result = value->Get<Vector4>();
61826           }
61827         }
61828       }
61829     } catch (std::out_of_range& e) {
61830       {
61831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61832       };
61833     } catch (std::exception& e) {
61834       {
61835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61836       };
61837     } catch (Dali::DaliException e) {
61838       {
61839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61840       };
61841     } catch (...) {
61842       {
61843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61844       };
61845     }
61846   }
61847
61848   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
61849   return jresult;
61850 }
61851
61852
61853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
61854   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61855   Dali::Property::Map *arg2 = 0 ;
61856
61857   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61858   arg2 = (Dali::Property::Map *)jarg2;
61859   if (!arg2) {
61860     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
61861     return ;
61862   }
61863   {
61864     try {
61865       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
61866     } catch (std::out_of_range& e) {
61867       {
61868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61869       };
61870     } catch (std::exception& e) {
61871       {
61872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61873       };
61874     } catch (Dali::DaliException e) {
61875       {
61876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61877       };
61878     } catch (...) {
61879       {
61880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61881       };
61882     }
61883   }
61884
61885 }
61886
61887
61888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
61889   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61890
61891   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61892   {
61893     try {
61894       (arg1)->ClearBackground();
61895     } catch (std::out_of_range& e) {
61896       {
61897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61898       };
61899     } catch (std::exception& e) {
61900       {
61901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61902       };
61903     } catch (Dali::DaliException e) {
61904       {
61905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61906       };
61907     } catch (...) {
61908       {
61909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61910       };
61911     }
61912   }
61913
61914 }
61915
61916
61917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
61918   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61919   Dali::Gesture::Type arg2 ;
61920
61921   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61922   arg2 = (Dali::Gesture::Type)jarg2;
61923   {
61924     try {
61925       (arg1)->EnableGestureDetection(arg2);
61926     } catch (std::out_of_range& e) {
61927       {
61928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61929       };
61930     } catch (std::exception& e) {
61931       {
61932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61933       };
61934     } catch (Dali::DaliException e) {
61935       {
61936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61937       };
61938     } catch (...) {
61939       {
61940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61941       };
61942     }
61943   }
61944
61945 }
61946
61947
61948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
61949   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61950   Dali::Gesture::Type arg2 ;
61951
61952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61953   arg2 = (Dali::Gesture::Type)jarg2;
61954   {
61955     try {
61956       (arg1)->DisableGestureDetection(arg2);
61957     } catch (std::out_of_range& e) {
61958       {
61959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61960       };
61961     } catch (std::exception& e) {
61962       {
61963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61964       };
61965     } catch (Dali::DaliException e) {
61966       {
61967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61968       };
61969     } catch (...) {
61970       {
61971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61972       };
61973     }
61974   }
61975
61976 }
61977
61978
61979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
61980   void * jresult ;
61981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61982   Dali::PinchGestureDetector result;
61983
61984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61985   {
61986     try {
61987       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
61988     } catch (std::out_of_range& e) {
61989       {
61990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61991       };
61992     } catch (std::exception& e) {
61993       {
61994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61995       };
61996     } catch (Dali::DaliException e) {
61997       {
61998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61999       };
62000     } catch (...) {
62001       {
62002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62003       };
62004     }
62005   }
62006
62007   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
62008   return jresult;
62009 }
62010
62011
62012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
62013   void * jresult ;
62014   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62015   Dali::PanGestureDetector result;
62016
62017   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62018   {
62019     try {
62020       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
62021     } catch (std::out_of_range& e) {
62022       {
62023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62024       };
62025     } catch (std::exception& e) {
62026       {
62027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62028       };
62029     } catch (Dali::DaliException e) {
62030       {
62031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62032       };
62033     } catch (...) {
62034       {
62035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62036       };
62037     }
62038   }
62039
62040   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
62041   return jresult;
62042 }
62043
62044
62045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
62046   void * jresult ;
62047   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62048   Dali::TapGestureDetector result;
62049
62050   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62051   {
62052     try {
62053       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
62054     } catch (std::out_of_range& e) {
62055       {
62056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62057       };
62058     } catch (std::exception& e) {
62059       {
62060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62061       };
62062     } catch (Dali::DaliException e) {
62063       {
62064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62065       };
62066     } catch (...) {
62067       {
62068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62069       };
62070     }
62071   }
62072
62073   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
62074   return jresult;
62075 }
62076
62077
62078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
62079   void * jresult ;
62080   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62081   Dali::LongPressGestureDetector result;
62082
62083   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62084   {
62085     try {
62086       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
62087     } catch (std::out_of_range& e) {
62088       {
62089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62090       };
62091     } catch (std::exception& e) {
62092       {
62093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62094       };
62095     } catch (Dali::DaliException e) {
62096       {
62097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62098       };
62099     } catch (...) {
62100       {
62101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62102       };
62103     }
62104   }
62105
62106   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
62107   return jresult;
62108 }
62109
62110
62111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
62112   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62113   bool arg2 ;
62114
62115   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62116   arg2 = jarg2 ? true : false;
62117   {
62118     try {
62119       (arg1)->SetKeyboardNavigationSupport(arg2);
62120     } catch (std::out_of_range& e) {
62121       {
62122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62123       };
62124     } catch (std::exception& e) {
62125       {
62126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62127       };
62128     } catch (Dali::DaliException e) {
62129       {
62130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62131       };
62132     } catch (...) {
62133       {
62134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62135       };
62136     }
62137   }
62138
62139 }
62140
62141
62142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
62143   unsigned int jresult ;
62144   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62145   bool result;
62146
62147   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62148   {
62149     try {
62150       result = (bool)(arg1)->IsKeyboardNavigationSupported();
62151     } catch (std::out_of_range& e) {
62152       {
62153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62154       };
62155     } catch (std::exception& e) {
62156       {
62157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62158       };
62159     } catch (Dali::DaliException e) {
62160       {
62161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62162       };
62163     } catch (...) {
62164       {
62165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62166       };
62167     }
62168   }
62169
62170   jresult = result;
62171   return jresult;
62172 }
62173
62174
62175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
62176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62177
62178   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62179   {
62180     try {
62181       (arg1)->SetKeyInputFocus();
62182     } catch (std::out_of_range& e) {
62183       {
62184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62185       };
62186     } catch (std::exception& e) {
62187       {
62188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62189       };
62190     } catch (Dali::DaliException e) {
62191       {
62192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62193       };
62194     } catch (...) {
62195       {
62196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62197       };
62198     }
62199   }
62200
62201 }
62202
62203
62204 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
62205   unsigned int jresult ;
62206   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62207   bool result;
62208
62209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62210   {
62211     try {
62212       result = (bool)(arg1)->HasKeyInputFocus();
62213     } catch (std::out_of_range& e) {
62214       {
62215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62216       };
62217     } catch (std::exception& e) {
62218       {
62219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62220       };
62221     } catch (Dali::DaliException e) {
62222       {
62223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62224       };
62225     } catch (...) {
62226       {
62227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62228       };
62229     }
62230   }
62231
62232   jresult = result;
62233   return jresult;
62234 }
62235
62236
62237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
62238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62239
62240   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62241   {
62242     try {
62243       (arg1)->ClearKeyInputFocus();
62244     } catch (std::out_of_range& e) {
62245       {
62246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62247       };
62248     } catch (std::exception& e) {
62249       {
62250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62251       };
62252     } catch (Dali::DaliException e) {
62253       {
62254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62255       };
62256     } catch (...) {
62257       {
62258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62259       };
62260     }
62261   }
62262
62263 }
62264
62265
62266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
62267   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62268   bool arg2 ;
62269
62270   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62271   arg2 = jarg2 ? true : false;
62272   {
62273     try {
62274       (arg1)->SetAsKeyboardFocusGroup(arg2);
62275     } catch (std::out_of_range& e) {
62276       {
62277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62278       };
62279     } catch (std::exception& e) {
62280       {
62281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62282       };
62283     } catch (Dali::DaliException e) {
62284       {
62285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62286       };
62287     } catch (...) {
62288       {
62289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62290       };
62291     }
62292   }
62293
62294 }
62295
62296
62297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
62298   unsigned int jresult ;
62299   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62300   bool result;
62301
62302   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62303   {
62304     try {
62305       result = (bool)(arg1)->IsKeyboardFocusGroup();
62306     } catch (std::out_of_range& e) {
62307       {
62308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62309       };
62310     } catch (std::exception& e) {
62311       {
62312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62313       };
62314     } catch (Dali::DaliException e) {
62315       {
62316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62317       };
62318     } catch (...) {
62319       {
62320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62321       };
62322     }
62323   }
62324
62325   jresult = result;
62326   return jresult;
62327 }
62328
62329
62330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
62331   void * jresult ;
62332   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62333   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
62334
62335   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62336   {
62337     try {
62338       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
62339     } catch (std::out_of_range& e) {
62340       {
62341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62342       };
62343     } catch (std::exception& e) {
62344       {
62345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62346       };
62347     } catch (Dali::DaliException e) {
62348       {
62349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62350       };
62351     } catch (...) {
62352       {
62353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62354       };
62355     }
62356   }
62357
62358   jresult = (void *)result;
62359   return jresult;
62360 }
62361
62362
62363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
62364   void * jresult ;
62365   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62366   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62367
62368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62369   {
62370     try {
62371       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
62372     } catch (std::out_of_range& e) {
62373       {
62374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62375       };
62376     } catch (std::exception& e) {
62377       {
62378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62379       };
62380     } catch (Dali::DaliException e) {
62381       {
62382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62383       };
62384     } catch (...) {
62385       {
62386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62387       };
62388     }
62389   }
62390
62391   jresult = (void *)result;
62392   return jresult;
62393 }
62394
62395
62396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
62397   void * jresult ;
62398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62399   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
62400
62401   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62402   {
62403     try {
62404       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
62405     } catch (std::out_of_range& e) {
62406       {
62407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62408       };
62409     } catch (std::exception& e) {
62410       {
62411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62412       };
62413     } catch (Dali::DaliException e) {
62414       {
62415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62416       };
62417     } catch (...) {
62418       {
62419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62420       };
62421     }
62422   }
62423
62424   jresult = (void *)result;
62425   return jresult;
62426 }
62427
62428
62429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
62430   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62431   int arg2 ;
62432   SwigDirector_ViewImpl *darg = 0;
62433
62434   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62435   arg2 = (int)jarg2;
62436   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62437   if(!darg) {
62438     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62439     return;
62440   }
62441   {
62442     try {
62443       if(darg) {
62444         (darg)->OnStageConnection(arg2);
62445       }
62446     } catch (std::out_of_range& e) {
62447       {
62448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62449       };
62450     } catch (std::exception& e) {
62451       {
62452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62453       };
62454     } catch (Dali::DaliException e) {
62455       {
62456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62457       };
62458     } catch (...) {
62459       {
62460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62461       };
62462     }
62463   }
62464
62465 }
62466
62467
62468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
62469   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62470   int arg2 ;
62471   SwigDirector_ViewImpl *darg = 0;
62472
62473   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62474   arg2 = (int)jarg2;
62475   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62476   if(!darg) {
62477     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62478     return;
62479   }
62480   {
62481     try {
62482       if(darg) {
62483         (darg)->OnStageConnectionSwigPublic(arg2);
62484       }
62485     } catch (std::out_of_range& e) {
62486       {
62487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62488       };
62489     } catch (std::exception& e) {
62490       {
62491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62492       };
62493     } catch (Dali::DaliException e) {
62494       {
62495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62496       };
62497     } catch (...) {
62498       {
62499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62500       };
62501     }
62502   }
62503
62504 }
62505
62506
62507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
62508   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62509   SwigDirector_ViewImpl *darg = 0;
62510
62511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62512   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62513   if(!darg) {
62514     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62515     return;
62516   }
62517   {
62518     try {
62519       if(darg) {
62520         (darg)->OnStageDisconnection();
62521       }
62522     } catch (std::out_of_range& e) {
62523       {
62524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62525       };
62526     } catch (std::exception& e) {
62527       {
62528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62529       };
62530     } catch (Dali::DaliException e) {
62531       {
62532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62533       };
62534     } catch (...) {
62535       {
62536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62537       };
62538     }
62539   }
62540
62541 }
62542
62543
62544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
62545   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62546   SwigDirector_ViewImpl *darg = 0;
62547
62548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62549   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62550   if(!darg) {
62551     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62552     return;
62553   }
62554   {
62555     try {
62556       if(darg) {
62557         (darg)->OnStageDisconnectionSwigPublic();
62558       }
62559     } catch (std::out_of_range& e) {
62560       {
62561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62562       };
62563     } catch (std::exception& e) {
62564       {
62565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62566       };
62567     } catch (Dali::DaliException e) {
62568       {
62569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62570       };
62571     } catch (...) {
62572       {
62573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62574       };
62575     }
62576   }
62577
62578 }
62579
62580
62581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
62582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62583   Dali::Actor *arg2 = 0 ;
62584   SwigDirector_ViewImpl *darg = 0;
62585
62586   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62587   arg2 = (Dali::Actor *)jarg2;
62588   if (!arg2) {
62589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62590     return ;
62591   }
62592   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62593   if(!darg) {
62594     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62595     return;
62596   }
62597   {
62598     try {
62599       if(darg) {
62600         (darg)->OnChildAdd(*arg2);
62601       }
62602     } catch (std::out_of_range& e) {
62603       {
62604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62605       };
62606     } catch (std::exception& e) {
62607       {
62608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62609       };
62610     } catch (Dali::DaliException e) {
62611       {
62612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62613       };
62614     } catch (...) {
62615       {
62616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62617       };
62618     }
62619   }
62620
62621 }
62622
62623
62624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62626   Dali::Actor *arg2 = 0 ;
62627   SwigDirector_ViewImpl *darg = 0;
62628
62629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62630   arg2 = (Dali::Actor *)jarg2;
62631   if (!arg2) {
62632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62633     return ;
62634   }
62635   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62636   if(!darg) {
62637     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62638     return;
62639   }
62640   {
62641     try {
62642       if(darg) {
62643           (darg)->OnChildAddSwigPublic(*arg2);
62644       }
62645     } catch (std::out_of_range& e) {
62646       {
62647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62648       };
62649     } catch (std::exception& e) {
62650       {
62651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62652       };
62653     } catch (Dali::DaliException e) {
62654       {
62655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62656       };
62657     } catch (...) {
62658       {
62659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62660       };
62661     }
62662   }
62663
62664 }
62665
62666
62667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
62668   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62669   Dali::Actor *arg2 = 0 ;
62670   SwigDirector_ViewImpl *darg = 0;
62671
62672   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62673   arg2 = (Dali::Actor *)jarg2;
62674   if (!arg2) {
62675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62676     return ;
62677   }
62678   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62679   if(!darg) {
62680     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62681     return;
62682   }
62683   {
62684     try {
62685       if(darg) {
62686         (darg)->OnChildRemove(*arg2);
62687       }
62688     } catch (std::out_of_range& e) {
62689       {
62690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62691       };
62692     } catch (std::exception& e) {
62693       {
62694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62695       };
62696     } catch (Dali::DaliException e) {
62697       {
62698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62699       };
62700     } catch (...) {
62701       {
62702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62703       };
62704     }
62705   }
62706
62707 }
62708
62709
62710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62711   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62712   Dali::Actor *arg2 = 0 ;
62713   SwigDirector_ViewImpl *darg = 0;
62714
62715   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62716   arg2 = (Dali::Actor *)jarg2;
62717   if (!arg2) {
62718     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
62719     return ;
62720   }
62721   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62722   if(!darg) {
62723     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62724     return;
62725   }
62726   {
62727     try {
62728       if(darg) {
62729         (darg)->OnChildRemoveSwigPublic(*arg2);
62730       }
62731     } catch (std::out_of_range& e) {
62732       {
62733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62734       };
62735     } catch (std::exception& e) {
62736       {
62737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62738       };
62739     } catch (Dali::DaliException e) {
62740       {
62741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62742       };
62743     } catch (...) {
62744       {
62745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62746       };
62747     }
62748   }
62749
62750 }
62751
62752
62753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
62754   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62755   Dali::Property::Index arg2 ;
62756   Dali::Property::Value arg3 ;
62757   Dali::Property::Value *argp3 ;
62758   SwigDirector_ViewImpl *darg = 0;
62759
62760   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62761   arg2 = (Dali::Property::Index)jarg2;
62762   argp3 = (Dali::Property::Value *)jarg3;
62763   if (!argp3) {
62764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
62765     return ;
62766   }
62767   arg3 = *argp3;
62768   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62769   if (!darg) {
62770     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62771     return;
62772   }
62773   {
62774     try {
62775       (darg)->OnPropertySet(arg2,arg3);
62776     } catch (std::out_of_range& e) {
62777       {
62778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62779       };
62780     } catch (std::exception& e) {
62781       {
62782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62783       };
62784     } catch (Dali::DaliException e) {
62785       {
62786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62787       };
62788     } catch (...) {
62789       {
62790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62791       };
62792     }
62793   }
62794
62795 }
62796
62797
62798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
62799   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62800   Dali::Property::Index arg2 ;
62801   Dali::Property::Value arg3 ;
62802   Dali::Property::Value *argp3 ;
62803   SwigDirector_ViewImpl *darg = 0;
62804
62805   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62806   arg2 = (Dali::Property::Index)jarg2;
62807   argp3 = (Dali::Property::Value *)jarg3;
62808   if (!argp3) {
62809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
62810     return ;
62811   }
62812   arg3 = *argp3;
62813   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62814   if (!darg) {
62815     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62816     return;
62817   }
62818   {
62819     try {
62820       (darg)->OnPropertySetSwigPublic(arg2,arg3);
62821     } catch (std::out_of_range& e) {
62822       {
62823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62824       };
62825     } catch (std::exception& e) {
62826       {
62827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62828       };
62829     } catch (Dali::DaliException e) {
62830       {
62831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62832       };
62833     } catch (...) {
62834       {
62835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62836       };
62837     }
62838   }
62839
62840 }
62841
62842
62843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
62844   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62845   Dali::Vector3 *arg2 = 0 ;
62846   SwigDirector_ViewImpl *darg = 0;
62847
62848   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62849   arg2 = (Dali::Vector3 *)jarg2;
62850   if (!arg2) {
62851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
62852     return ;
62853   }
62854   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62855   if (!darg) {
62856     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62857     return;
62858   }
62859   {
62860     try {
62861       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
62862     } catch (std::out_of_range& e) {
62863       {
62864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62865       };
62866     } catch (std::exception& e) {
62867       {
62868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62869       };
62870     } catch (Dali::DaliException e) {
62871       {
62872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62873       };
62874     } catch (...) {
62875       {
62876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62877       };
62878     }
62879   }
62880
62881 }
62882
62883
62884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62885   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62886   Dali::Vector3 *arg2 = 0 ;
62887   SwigDirector_ViewImpl *darg = 0;
62888
62889   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62890   arg2 = (Dali::Vector3 *)jarg2;
62891   if (!arg2) {
62892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
62893     return ;
62894   }
62895   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62896   if (!darg) {
62897     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62898     return;
62899   }
62900   {
62901     try {
62902       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
62903     } catch (std::out_of_range& e) {
62904       {
62905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62906       };
62907     } catch (std::exception& e) {
62908       {
62909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62910       };
62911     } catch (Dali::DaliException e) {
62912       {
62913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62914       };
62915     } catch (...) {
62916       {
62917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62918       };
62919     }
62920   }
62921
62922 }
62923
62924
62925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
62926   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62927   Dali::Animation *arg2 = 0 ;
62928   Dali::Vector3 *arg3 = 0 ;
62929   SwigDirector_ViewImpl *darg = 0;
62930
62931   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62932   arg2 = (Dali::Animation *)jarg2;
62933   if (!arg2) {
62934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
62935     return ;
62936   }
62937   arg3 = (Dali::Vector3 *)jarg3;
62938   if (!arg3) {
62939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
62940     return ;
62941   }
62942   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62943   if (!darg) {
62944     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62945     return;
62946   }
62947   {
62948     try {
62949       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
62950     } catch (std::out_of_range& e) {
62951       {
62952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62953       };
62954     } catch (std::exception& e) {
62955       {
62956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62957       };
62958     } catch (Dali::DaliException e) {
62959       {
62960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62961       };
62962     } catch (...) {
62963       {
62964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62965       };
62966     }
62967   }
62968
62969 }
62970
62971
62972 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62973   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62974   Dali::Animation *arg2 = 0 ;
62975   Dali::Vector3 *arg3 = 0 ;
62976   SwigDirector_ViewImpl *darg = 0;
62977
62978   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62979   arg2 = (Dali::Animation *)jarg2;
62980   if (!arg2) {
62981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
62982     return ;
62983   }
62984   arg3 = (Dali::Vector3 *)jarg3;
62985   if (!arg3) {
62986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
62987     return ;
62988   }
62989   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
62990   if (!darg) {
62991     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
62992     return;
62993   }
62994   {
62995     try {
62996       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
62997     } catch (std::out_of_range& e) {
62998       {
62999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63000       };
63001     } catch (std::exception& e) {
63002       {
63003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63004       };
63005     } catch (Dali::DaliException e) {
63006       {
63007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63008       };
63009     } catch (...) {
63010       {
63011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63012       };
63013     }
63014   }
63015
63016 }
63017
63018
63019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
63020   unsigned int jresult ;
63021   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63022   Dali::TouchEvent *arg2 = 0 ;
63023   SwigDirector_ViewImpl *darg = 0;
63024   bool result;
63025
63026   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63027   arg2 = (Dali::TouchEvent *)jarg2;
63028   if (!arg2) {
63029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
63030     return 0;
63031   }
63032   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63033   if (!darg) {
63034     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63035     return 0;
63036   }
63037   {
63038     try {
63039       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
63040     } catch (std::out_of_range& e) {
63041       {
63042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63043       };
63044     } catch (std::exception& e) {
63045       {
63046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63047       };
63048     } catch (Dali::DaliException e) {
63049       {
63050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63051       };
63052     } catch (...) {
63053       {
63054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63055       };
63056     }
63057   }
63058
63059   jresult = result;
63060   return jresult;
63061 }
63062
63063
63064 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63065   unsigned int jresult ;
63066   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63067   Dali::TouchEvent *arg2 = 0 ;
63068   SwigDirector_ViewImpl *darg = 0;
63069   bool result;
63070
63071   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63072   arg2 = (Dali::TouchEvent *)jarg2;
63073   if (!arg2) {
63074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
63075     return 0;
63076   }
63077   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63078   if (!darg) {
63079     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63080     return 0;
63081   }
63082   {
63083     try {
63084       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
63085     } catch (std::out_of_range& e) {
63086       {
63087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63088       };
63089     } catch (std::exception& e) {
63090       {
63091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63092       };
63093     } catch (Dali::DaliException e) {
63094       {
63095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63096       };
63097     } catch (...) {
63098       {
63099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63100       };
63101     }
63102   }
63103
63104   jresult = result;
63105   return jresult;
63106 }
63107
63108
63109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
63110   unsigned int jresult ;
63111   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63112   Dali::HoverEvent *arg2 = 0 ;
63113   SwigDirector_ViewImpl *darg = 0;
63114   bool result;
63115
63116   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63117   arg2 = (Dali::HoverEvent *)jarg2;
63118   if (!arg2) {
63119     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
63120     return 0;
63121   }
63122   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63123   if (!darg) {
63124     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63125     return 0;
63126   }
63127   {
63128     try {
63129       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
63130     } catch (std::out_of_range& e) {
63131       {
63132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63133       };
63134     } catch (std::exception& e) {
63135       {
63136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63137       };
63138     } catch (Dali::DaliException e) {
63139       {
63140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63141       };
63142     } catch (...) {
63143       {
63144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63145       };
63146     }
63147   }
63148
63149   jresult = result;
63150   return jresult;
63151 }
63152
63153
63154 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63155   unsigned int jresult ;
63156   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63157   Dali::HoverEvent *arg2 = 0 ;
63158   SwigDirector_ViewImpl *darg = 0;
63159   bool result;
63160
63161   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63162   arg2 = (Dali::HoverEvent *)jarg2;
63163   if (!arg2) {
63164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
63165     return 0;
63166   }
63167   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63168   if (!darg) {
63169     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63170     return 0;
63171   }
63172   {
63173     try {
63174       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
63175     } catch (std::out_of_range& e) {
63176       {
63177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63178       };
63179     } catch (std::exception& e) {
63180       {
63181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63182       };
63183     } catch (Dali::DaliException e) {
63184       {
63185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63186       };
63187     } catch (...) {
63188       {
63189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63190       };
63191     }
63192   }
63193
63194   jresult = result;
63195   return jresult;
63196 }
63197
63198
63199 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
63200   unsigned int jresult ;
63201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63202   Dali::KeyEvent *arg2 = 0 ;
63203   SwigDirector_ViewImpl *darg = 0;
63204   bool result;
63205
63206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63207   arg2 = (Dali::KeyEvent *)jarg2;
63208   if (!arg2) {
63209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
63210     return 0;
63211   }
63212   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63213   if (!darg) {
63214     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63215     return 0;
63216   }
63217   {
63218     try {
63219       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
63220     } catch (std::out_of_range& e) {
63221       {
63222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63223       };
63224     } catch (std::exception& e) {
63225       {
63226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63227       };
63228     } catch (Dali::DaliException e) {
63229       {
63230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63231       };
63232     } catch (...) {
63233       {
63234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63235       };
63236     }
63237   }
63238
63239   jresult = result;
63240   return jresult;
63241 }
63242
63243
63244 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63245   unsigned int jresult ;
63246   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63247   Dali::KeyEvent *arg2 = 0 ;
63248   SwigDirector_ViewImpl *darg = 0;
63249   bool result;
63250
63251   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63252   arg2 = (Dali::KeyEvent *)jarg2;
63253   if (!arg2) {
63254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
63255     return 0;
63256   }
63257   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63258   if (!darg) {
63259     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63260     return 0;
63261   }
63262   {
63263     try {
63264       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
63265     } catch (std::out_of_range& e) {
63266       {
63267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63268       };
63269     } catch (std::exception& e) {
63270       {
63271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63272       };
63273     } catch (Dali::DaliException e) {
63274       {
63275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63276       };
63277     } catch (...) {
63278       {
63279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63280       };
63281     }
63282   }
63283
63284   jresult = result;
63285   return jresult;
63286 }
63287
63288
63289 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
63290   unsigned int jresult ;
63291   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63292   Dali::WheelEvent *arg2 = 0 ;
63293   SwigDirector_ViewImpl *darg = 0;
63294   bool result;
63295
63296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63297   arg2 = (Dali::WheelEvent *)jarg2;
63298   if (!arg2) {
63299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
63300     return 0;
63301   }
63302   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63303   if (!darg) {
63304     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63305     return 0;
63306   }
63307   {
63308     try {
63309       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
63310     } catch (std::out_of_range& e) {
63311       {
63312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63313       };
63314     } catch (std::exception& e) {
63315       {
63316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63317       };
63318     } catch (Dali::DaliException e) {
63319       {
63320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63321       };
63322     } catch (...) {
63323       {
63324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63325       };
63326     }
63327   }
63328
63329   jresult = result;
63330   return jresult;
63331 }
63332
63333
63334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63335   unsigned int jresult ;
63336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63337   Dali::WheelEvent *arg2 = 0 ;
63338   SwigDirector_ViewImpl *darg = 0;
63339   bool result;
63340
63341   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63342   arg2 = (Dali::WheelEvent *)jarg2;
63343   if (!arg2) {
63344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
63345     return 0;
63346   }
63347   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63348   if (!darg) {
63349     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63350     return 0;
63351   }
63352   {
63353     try {
63354       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
63355     } catch (std::out_of_range& e) {
63356       {
63357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63358       };
63359     } catch (std::exception& e) {
63360       {
63361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63362       };
63363     } catch (Dali::DaliException e) {
63364       {
63365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63366       };
63367     } catch (...) {
63368       {
63369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63370       };
63371     }
63372   }
63373
63374   jresult = result;
63375   return jresult;
63376 }
63377
63378
63379 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
63380   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63381   Dali::Vector2 *arg2 = 0 ;
63382   Dali::RelayoutContainer *arg3 = 0 ;
63383   SwigDirector_ViewImpl *darg = 0;
63384
63385   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63386   arg2 = (Dali::Vector2 *)jarg2;
63387   if (!arg2) {
63388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
63389     return ;
63390   }
63391   arg3 = (Dali::RelayoutContainer *)jarg3;
63392   if (!arg3) {
63393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
63394     return ;
63395   }
63396   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63397   if (!darg) {
63398     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63399     return;
63400   }
63401   {
63402     try {
63403       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
63404     } catch (std::out_of_range& e) {
63405       {
63406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63407       };
63408     } catch (std::exception& e) {
63409       {
63410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63411       };
63412     } catch (Dali::DaliException e) {
63413       {
63414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63415       };
63416     } catch (...) {
63417       {
63418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63419       };
63420     }
63421   }
63422
63423 }
63424
63425
63426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63427   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63428   Dali::Vector2 *arg2 = 0 ;
63429   Dali::RelayoutContainer *arg3 = 0 ;
63430   SwigDirector_ViewImpl *darg = 0;
63431
63432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63433   arg2 = (Dali::Vector2 *)jarg2;
63434   if (!arg2) {
63435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
63436     return ;
63437   }
63438   arg3 = (Dali::RelayoutContainer *)jarg3;
63439   if (!arg3) {
63440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
63441     return ;
63442   }
63443   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63444   if (!darg) {
63445     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63446     return;
63447   }
63448   {
63449     try {
63450       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
63451     } catch (std::out_of_range& e) {
63452       {
63453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63454       };
63455     } catch (std::exception& e) {
63456       {
63457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63458       };
63459     } catch (Dali::DaliException e) {
63460       {
63461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63462       };
63463     } catch (...) {
63464       {
63465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63466       };
63467     }
63468   }
63469
63470 }
63471
63472
63473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
63474   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63475   Dali::ResizePolicy::Type arg2 ;
63476   Dali::Dimension::Type arg3 ;
63477   SwigDirector_ViewImpl *darg = 0;
63478
63479   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63480   arg2 = (Dali::ResizePolicy::Type)jarg2;
63481   arg3 = (Dali::Dimension::Type)jarg3;
63482   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63483   if (!darg) {
63484     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63485     return;
63486   }
63487   {
63488     try {
63489       (darg)->OnSetResizePolicy(arg2,arg3);
63490     } catch (std::out_of_range& e) {
63491       {
63492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63493       };
63494     } catch (std::exception& e) {
63495       {
63496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63497       };
63498     } catch (Dali::DaliException e) {
63499       {
63500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63501       };
63502     } catch (...) {
63503       {
63504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63505       };
63506     }
63507   }
63508
63509 }
63510
63511
63512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
63513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63514   Dali::ResizePolicy::Type arg2 ;
63515   Dali::Dimension::Type arg3 ;
63516   SwigDirector_ViewImpl *darg = 0;
63517
63518   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63519   arg2 = (Dali::ResizePolicy::Type)jarg2;
63520   arg3 = (Dali::Dimension::Type)jarg3;
63521   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63522   if (!darg) {
63523     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63524     return;
63525   }
63526   {
63527     try {
63528       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
63529     } catch (std::out_of_range& e) {
63530       {
63531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63532       };
63533     } catch (std::exception& e) {
63534       {
63535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63536       };
63537     } catch (Dali::DaliException e) {
63538       {
63539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63540       };
63541     } catch (...) {
63542       {
63543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63544       };
63545     }
63546   }
63547
63548 }
63549
63550
63551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
63552   void * jresult ;
63553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63554   SwigDirector_ViewImpl *darg = 0;
63555   Dali::Vector3 result;
63556
63557   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63558   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63559   if (!darg) {
63560     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63561     return 0;
63562   }
63563   {
63564     try {
63565       result = (darg)->GetNaturalSize();
63566     } catch (std::out_of_range& e) {
63567       {
63568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63569       };
63570     } catch (std::exception& e) {
63571       {
63572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63573       };
63574     } catch (Dali::DaliException e) {
63575       {
63576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63577       };
63578     } catch (...) {
63579       {
63580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63581       };
63582     }
63583   }
63584
63585   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
63586   return jresult;
63587 }
63588
63589
63590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
63591   void * jresult ;
63592   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63593   SwigDirector_ViewImpl *darg = 0;
63594   Dali::Vector3 result;
63595
63596   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63597   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63598   if (!darg) {
63599     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63600     return 0;
63601   }
63602   {
63603     try {
63604       result = (darg)->GetNaturalSizeSwigPublic();
63605     } catch (std::out_of_range& e) {
63606       {
63607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63608       };
63609     } catch (std::exception& e) {
63610       {
63611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63612       };
63613     } catch (Dali::DaliException e) {
63614       {
63615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63616       };
63617     } catch (...) {
63618       {
63619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63620       };
63621     }
63622   }
63623
63624   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
63625   return jresult;
63626 }
63627
63628
63629 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
63630   float jresult ;
63631   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63632   Dali::Actor *arg2 = 0 ;
63633   Dali::Dimension::Type arg3 ;
63634   SwigDirector_ViewImpl *darg = 0;
63635   float result;
63636
63637   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63638   arg2 = (Dali::Actor *)jarg2;
63639   if (!arg2) {
63640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
63641     return 0;
63642   }
63643   arg3 = (Dali::Dimension::Type)jarg3;
63644   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63645   if (!darg) {
63646     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63647     return 0;
63648   }
63649   {
63650     try {
63651       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
63652     } catch (std::out_of_range& e) {
63653       {
63654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63655       };
63656     } catch (std::exception& e) {
63657       {
63658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63659       };
63660     } catch (Dali::DaliException e) {
63661       {
63662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63663       };
63664     } catch (...) {
63665       {
63666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63667       };
63668     }
63669   }
63670
63671   jresult = result;
63672   return jresult;
63673 }
63674
63675
63676 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
63677   float jresult ;
63678   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63679   Dali::Actor *arg2 = 0 ;
63680   Dali::Dimension::Type arg3 ;
63681   SwigDirector_ViewImpl *darg = 0;
63682   float result;
63683
63684   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63685   arg2 = (Dali::Actor *)jarg2;
63686   if (!arg2) {
63687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
63688     return 0;
63689   }
63690   arg3 = (Dali::Dimension::Type)jarg3;
63691   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63692   if (!darg) {
63693     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63694     return 0;
63695   }
63696   {
63697     try {
63698       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
63699     } catch (std::out_of_range& e) {
63700       {
63701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63702       };
63703     } catch (std::exception& e) {
63704       {
63705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63706       };
63707     } catch (Dali::DaliException e) {
63708       {
63709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63710       };
63711     } catch (...) {
63712       {
63713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63714       };
63715     }
63716   }
63717
63718   jresult = result;
63719   return jresult;
63720 }
63721
63722
63723 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
63724   float jresult ;
63725   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63726   float arg2 ;
63727   SwigDirector_ViewImpl *darg = 0;
63728   float result;
63729
63730   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63731   arg2 = (float)jarg2;
63732   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63733   if (!darg) {
63734     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63735     return 0;
63736   }
63737   {
63738     try {
63739       result = (float)(darg)->GetHeightForWidth(arg2);
63740     } catch (std::out_of_range& e) {
63741       {
63742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63743       };
63744     } catch (std::exception& e) {
63745       {
63746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63747       };
63748     } catch (Dali::DaliException e) {
63749       {
63750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63751       };
63752     } catch (...) {
63753       {
63754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63755       };
63756     }
63757   }
63758
63759   jresult = result;
63760   return jresult;
63761 }
63762
63763
63764 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
63765   float jresult ;
63766   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63767   float arg2 ;
63768   SwigDirector_ViewImpl *darg = 0;
63769   float result;
63770
63771   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63772   arg2 = (float)jarg2;
63773   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63774   if (!darg) {
63775     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63776     return 0;
63777   }
63778   {
63779     try {
63780       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
63781     } catch (std::out_of_range& e) {
63782       {
63783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63784       };
63785     } catch (std::exception& e) {
63786       {
63787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63788       };
63789     } catch (Dali::DaliException e) {
63790       {
63791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63792       };
63793     } catch (...) {
63794       {
63795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63796       };
63797     }
63798   }
63799
63800   jresult = result;
63801   return jresult;
63802 }
63803
63804
63805 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
63806   float jresult ;
63807   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63808   float arg2 ;
63809   SwigDirector_ViewImpl *darg = 0;
63810   float result;
63811
63812   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63813   arg2 = (float)jarg2;
63814   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63815   if (!darg) {
63816     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63817     return 0;
63818   }
63819   {
63820     try {
63821       result = (float)(darg)->GetWidthForHeight(arg2);
63822     } catch (std::out_of_range& e) {
63823       {
63824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63825       };
63826     } catch (std::exception& e) {
63827       {
63828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63829       };
63830     } catch (Dali::DaliException e) {
63831       {
63832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63833       };
63834     } catch (...) {
63835       {
63836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63837       };
63838     }
63839   }
63840
63841   jresult = result;
63842   return jresult;
63843 }
63844
63845
63846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
63847   float jresult ;
63848   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63849   float arg2 ;
63850   SwigDirector_ViewImpl *darg = 0;
63851   float result;
63852
63853   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63854   arg2 = (float)jarg2;
63855   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63856   if (!darg) {
63857     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63858     return 0;
63859   }
63860   {
63861     try {
63862       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
63863     } catch (std::out_of_range& e) {
63864       {
63865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63866       };
63867     } catch (std::exception& e) {
63868       {
63869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63870       };
63871     } catch (Dali::DaliException e) {
63872       {
63873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63874       };
63875     } catch (...) {
63876       {
63877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63878       };
63879     }
63880   }
63881
63882   jresult = result;
63883   return jresult;
63884 }
63885
63886
63887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
63888   unsigned int jresult ;
63889   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63890   Dali::Dimension::Type arg2 ;
63891   SwigDirector_ViewImpl *darg = 0;
63892   bool result;
63893
63894   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63895   arg2 = (Dali::Dimension::Type)jarg2;
63896   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63897   if (!darg) {
63898     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63899     return 0;
63900   }
63901   {
63902     try {
63903       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
63904     } catch (std::out_of_range& e) {
63905       {
63906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63907       };
63908     } catch (std::exception& e) {
63909       {
63910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63911       };
63912     } catch (Dali::DaliException e) {
63913       {
63914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63915       };
63916     } catch (...) {
63917       {
63918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63919       };
63920     }
63921   }
63922
63923   jresult = result;
63924   return jresult;
63925 }
63926
63927
63928 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
63929   unsigned int jresult ;
63930   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63931   Dali::Dimension::Type arg2 ;
63932   SwigDirector_ViewImpl *darg = 0;
63933   bool result;
63934
63935   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63936   arg2 = (Dali::Dimension::Type)jarg2;
63937   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63938   if (!darg) {
63939     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63940     return 0;
63941   }
63942   {
63943     try {
63944       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
63945     } catch (std::out_of_range& e) {
63946       {
63947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63948       };
63949     } catch (std::exception& e) {
63950       {
63951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63952       };
63953     } catch (Dali::DaliException e) {
63954       {
63955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63956       };
63957     } catch (...) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63960       };
63961     }
63962   }
63963
63964   jresult = result;
63965   return jresult;
63966 }
63967
63968
63969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
63970   unsigned int jresult ;
63971   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63972   SwigDirector_ViewImpl *darg = 0;
63973   bool result;
63974
63975   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63976   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
63977   if (!darg) {
63978     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
63979     return 0;
63980   }
63981   {
63982     try {
63983       result = (bool)(darg)->RelayoutDependentOnChildren();
63984     } catch (std::out_of_range& e) {
63985       {
63986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63987       };
63988     } catch (std::exception& e) {
63989       {
63990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63991       };
63992     } catch (Dali::DaliException e) {
63993       {
63994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63995       };
63996     } catch (...) {
63997       {
63998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63999       };
64000     }
64001   }
64002
64003   jresult = result;
64004   return jresult;
64005 }
64006
64007
64008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
64009   unsigned int jresult ;
64010   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64011   SwigDirector_ViewImpl *darg = 0;
64012   bool result;
64013
64014   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64015   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64016   if (!darg) {
64017     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64018     return 0;
64019   }
64020   {
64021     try {
64022       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
64023     } catch (std::out_of_range& e) {
64024       {
64025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64026       };
64027     } catch (std::exception& e) {
64028       {
64029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64030       };
64031     } catch (Dali::DaliException e) {
64032       {
64033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64034       };
64035     } catch (...) {
64036       {
64037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64038       };
64039     }
64040   }
64041
64042   jresult = result;
64043   return jresult;
64044 }
64045
64046
64047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
64048   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64049   Dali::Dimension::Type arg2 ;
64050   SwigDirector_ViewImpl *darg = 0;
64051
64052   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64053   arg2 = (Dali::Dimension::Type)jarg2;
64054   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64055   if (!darg) {
64056     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64057     return;
64058   }
64059   {
64060     try {
64061       (darg)->OnCalculateRelayoutSize(arg2);
64062     } catch (std::out_of_range& e) {
64063       {
64064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64065       };
64066     } catch (std::exception& e) {
64067       {
64068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64069       };
64070     } catch (Dali::DaliException e) {
64071       {
64072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64073       };
64074     } catch (...) {
64075       {
64076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64077       };
64078     }
64079   }
64080
64081 }
64082
64083
64084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
64085   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64086   Dali::Dimension::Type arg2 ;
64087   SwigDirector_ViewImpl *darg = 0;
64088
64089   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64090   arg2 = (Dali::Dimension::Type)jarg2;
64091   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64092   if (!darg) {
64093     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64094     return;
64095   }
64096   {
64097     try {
64098       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
64099     } catch (std::out_of_range& e) {
64100       {
64101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64102       };
64103     } catch (std::exception& e) {
64104       {
64105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64106       };
64107     } catch (Dali::DaliException e) {
64108       {
64109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64110       };
64111     } catch (...) {
64112       {
64113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64114       };
64115     }
64116   }
64117
64118 }
64119
64120
64121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
64122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64123   float arg2 ;
64124   Dali::Dimension::Type arg3 ;
64125   SwigDirector_ViewImpl *darg = 0;
64126
64127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64128   arg2 = (float)jarg2;
64129   arg3 = (Dali::Dimension::Type)jarg3;
64130   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64131   if (!darg) {
64132     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64133     return;
64134   }
64135   {
64136     try {
64137       (darg)->OnLayoutNegotiated(arg2,arg3);
64138     } catch (std::out_of_range& e) {
64139       {
64140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64141       };
64142     } catch (std::exception& e) {
64143       {
64144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64145       };
64146     } catch (Dali::DaliException e) {
64147       {
64148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64149       };
64150     } catch (...) {
64151       {
64152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64153       };
64154     }
64155   }
64156
64157 }
64158
64159
64160 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
64161   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64162   float arg2 ;
64163   Dali::Dimension::Type arg3 ;
64164   SwigDirector_ViewImpl *darg = 0;
64165
64166   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64167   arg2 = (float)jarg2;
64168   arg3 = (Dali::Dimension::Type)jarg3;
64169   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
64170   if (!darg) {
64171     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
64172     return;
64173   }
64174   {
64175     try {
64176       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
64177     } catch (std::out_of_range& e) {
64178       {
64179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64180       };
64181     } catch (std::exception& e) {
64182       {
64183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64184       };
64185     } catch (Dali::DaliException e) {
64186       {
64187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64188       };
64189     } catch (...) {
64190       {
64191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64192       };
64193     }
64194   }
64195
64196 }
64197
64198
64199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
64200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64201
64202   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64203   {
64204     try {
64205       (arg1)->OnInitialize();
64206     } catch (std::out_of_range& e) {
64207       {
64208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64209       };
64210     } catch (std::exception& e) {
64211       {
64212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64213       };
64214     } catch (Dali::DaliException e) {
64215       {
64216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64217       };
64218     } catch (...) {
64219       {
64220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64221       };
64222     }
64223   }
64224
64225 }
64226
64227
64228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
64229   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64230
64231   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64232   {
64233     try {
64234       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
64235     } catch (std::out_of_range& e) {
64236       {
64237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64238       };
64239     } catch (std::exception& e) {
64240       {
64241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64242       };
64243     } catch (Dali::DaliException e) {
64244       {
64245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64246       };
64247     } catch (...) {
64248       {
64249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64250       };
64251     }
64252   }
64253
64254 }
64255
64256
64257 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAdd(void * jarg1, void * jarg2) {
64258   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64259   Dali::Actor *arg2 = 0 ;
64260
64261   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64262   arg2 = (Dali::Actor *)jarg2;
64263   if (!arg2) {
64264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64265     return ;
64266   }
64267   {
64268     try {
64269       (arg1)->OnControlChildAdd(*arg2);
64270     } catch (std::out_of_range& e) {
64271       {
64272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64273       };
64274     } catch (std::exception& e) {
64275       {
64276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64277       };
64278     } catch (Dali::DaliException e) {
64279       {
64280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64281       };
64282     } catch (...) {
64283       {
64284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64285       };
64286     }
64287   }
64288
64289 }
64290
64291
64292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64293   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64294   Dali::Actor *arg2 = 0 ;
64295
64296   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64297   arg2 = (Dali::Actor *)jarg2;
64298   if (!arg2) {
64299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64300     return ;
64301   }
64302   {
64303     try {
64304       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildAdd(*arg2);
64305     } catch (std::out_of_range& e) {
64306       {
64307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64308       };
64309     } catch (std::exception& e) {
64310       {
64311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64312       };
64313     } catch (Dali::DaliException e) {
64314       {
64315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64316       };
64317     } catch (...) {
64318       {
64319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64320       };
64321     }
64322   }
64323
64324 }
64325
64326
64327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemove(void * jarg1, void * jarg2) {
64328   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64329   Dali::Actor *arg2 = 0 ;
64330
64331   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64332   arg2 = (Dali::Actor *)jarg2;
64333   if (!arg2) {
64334     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64335     return ;
64336   }
64337   {
64338     try {
64339       (arg1)->OnControlChildRemove(*arg2);
64340     } catch (std::out_of_range& e) {
64341       {
64342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64343       };
64344     } catch (std::exception& e) {
64345       {
64346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64347       };
64348     } catch (Dali::DaliException e) {
64349       {
64350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64351       };
64352     } catch (...) {
64353       {
64354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64355       };
64356     }
64357   }
64358
64359 }
64360
64361
64362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnControlChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64364   Dali::Actor *arg2 = 0 ;
64365
64366   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64367   arg2 = (Dali::Actor *)jarg2;
64368   if (!arg2) {
64369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
64370     return ;
64371   }
64372   {
64373     try {
64374       (arg1)->Dali::Toolkit::Internal::Control::OnControlChildRemove(*arg2);
64375     } catch (std::out_of_range& e) {
64376       {
64377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64378       };
64379     } catch (std::exception& e) {
64380       {
64381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64382       };
64383     } catch (Dali::DaliException e) {
64384       {
64385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64386       };
64387     } catch (...) {
64388       {
64389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64390       };
64391     }
64392   }
64393
64394 }
64395
64396
64397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
64398   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64399   Dali::Toolkit::StyleManager arg2 ;
64400   Dali::StyleChange::Type arg3 ;
64401   Dali::Toolkit::StyleManager *argp2 ;
64402
64403   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64404   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
64405   if (!argp2) {
64406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
64407     return ;
64408   }
64409   arg2 = *argp2;
64410   arg3 = (Dali::StyleChange::Type)jarg3;
64411   {
64412     try {
64413       (arg1)->OnStyleChange(arg2,arg3);
64414     } catch (std::out_of_range& e) {
64415       {
64416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64417       };
64418     } catch (std::exception& e) {
64419       {
64420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64421       };
64422     } catch (Dali::DaliException e) {
64423       {
64424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64425       };
64426     } catch (...) {
64427       {
64428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64429       };
64430     }
64431   }
64432
64433 }
64434
64435
64436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
64437   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64438   Dali::Toolkit::StyleManager arg2 ;
64439   Dali::StyleChange::Type arg3 ;
64440   Dali::Toolkit::StyleManager *argp2 ;
64441
64442   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64443   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
64444   if (!argp2) {
64445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
64446     return ;
64447   }
64448   arg2 = *argp2;
64449   arg3 = (Dali::StyleChange::Type)jarg3;
64450   {
64451     try {
64452       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
64453     } catch (std::out_of_range& e) {
64454       {
64455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64456       };
64457     } catch (std::exception& e) {
64458       {
64459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64460       };
64461     } catch (Dali::DaliException e) {
64462       {
64463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64464       };
64465     } catch (...) {
64466       {
64467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64468       };
64469     }
64470   }
64471
64472 }
64473
64474
64475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
64476   unsigned int jresult ;
64477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64478   bool result;
64479
64480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64481   {
64482     try {
64483       result = (bool)(arg1)->OnAccessibilityActivated();
64484     } catch (std::out_of_range& e) {
64485       {
64486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64487       };
64488     } catch (std::exception& e) {
64489       {
64490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64491       };
64492     } catch (Dali::DaliException e) {
64493       {
64494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64495       };
64496     } catch (...) {
64497       {
64498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64499       };
64500     }
64501   }
64502
64503   jresult = result;
64504   return jresult;
64505 }
64506
64507
64508 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
64509   unsigned int jresult ;
64510   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64511   bool result;
64512
64513   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64514   {
64515     try {
64516       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
64517     } catch (std::out_of_range& e) {
64518       {
64519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64520       };
64521     } catch (std::exception& e) {
64522       {
64523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64524       };
64525     } catch (Dali::DaliException e) {
64526       {
64527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64528       };
64529     } catch (...) {
64530       {
64531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64532       };
64533     }
64534   }
64535
64536   jresult = result;
64537   return jresult;
64538 }
64539
64540
64541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
64542   unsigned int jresult ;
64543   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64544   Dali::PanGesture arg2 ;
64545   Dali::PanGesture *argp2 ;
64546   bool result;
64547
64548   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64549   argp2 = (Dali::PanGesture *)jarg2;
64550   if (!argp2) {
64551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
64552     return 0;
64553   }
64554   arg2 = *argp2;
64555   {
64556     try {
64557       result = (bool)(arg1)->OnAccessibilityPan(arg2);
64558     } catch (std::out_of_range& e) {
64559       {
64560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64561       };
64562     } catch (std::exception& e) {
64563       {
64564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64565       };
64566     } catch (Dali::DaliException e) {
64567       {
64568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64569       };
64570     } catch (...) {
64571       {
64572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64573       };
64574     }
64575   }
64576
64577   jresult = result;
64578   return jresult;
64579 }
64580
64581
64582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64583   unsigned int jresult ;
64584   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64585   Dali::PanGesture arg2 ;
64586   Dali::PanGesture *argp2 ;
64587   bool result;
64588
64589   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64590   argp2 = (Dali::PanGesture *)jarg2;
64591   if (!argp2) {
64592     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
64593     return 0;
64594   }
64595   arg2 = *argp2;
64596   {
64597     try {
64598       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
64599     } catch (std::out_of_range& e) {
64600       {
64601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64602       };
64603     } catch (std::exception& e) {
64604       {
64605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64606       };
64607     } catch (Dali::DaliException e) {
64608       {
64609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64610       };
64611     } catch (...) {
64612       {
64613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64614       };
64615     }
64616   }
64617
64618   jresult = result;
64619   return jresult;
64620 }
64621
64622
64623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
64624   unsigned int jresult ;
64625   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64626   Dali::TouchEvent *arg2 = 0 ;
64627   bool result;
64628
64629   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64630   arg2 = (Dali::TouchEvent *)jarg2;
64631   if (!arg2) {
64632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64633     return 0;
64634   }
64635   {
64636     try {
64637       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
64638     } catch (std::out_of_range& e) {
64639       {
64640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64641       };
64642     } catch (std::exception& e) {
64643       {
64644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64645       };
64646     } catch (Dali::DaliException e) {
64647       {
64648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64649       };
64650     } catch (...) {
64651       {
64652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64653       };
64654     }
64655   }
64656
64657   jresult = result;
64658   return jresult;
64659 }
64660
64661
64662 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
64663   unsigned int jresult ;
64664   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64665   Dali::TouchEvent *arg2 = 0 ;
64666   bool result;
64667
64668   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64669   arg2 = (Dali::TouchEvent *)jarg2;
64670   if (!arg2) {
64671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
64672     return 0;
64673   }
64674   {
64675     try {
64676       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
64677     } catch (std::out_of_range& e) {
64678       {
64679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64680       };
64681     } catch (std::exception& e) {
64682       {
64683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64684       };
64685     } catch (Dali::DaliException e) {
64686       {
64687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64688       };
64689     } catch (...) {
64690       {
64691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64692       };
64693     }
64694   }
64695
64696   jresult = result;
64697   return jresult;
64698 }
64699
64700
64701 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
64702   unsigned int jresult ;
64703   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64704   bool arg2 ;
64705   bool result;
64706
64707   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64708   arg2 = jarg2 ? true : false;
64709   {
64710     try {
64711       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
64712     } catch (std::out_of_range& e) {
64713       {
64714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64715       };
64716     } catch (std::exception& e) {
64717       {
64718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64719       };
64720     } catch (Dali::DaliException e) {
64721       {
64722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64723       };
64724     } catch (...) {
64725       {
64726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64727       };
64728     }
64729   }
64730
64731   jresult = result;
64732   return jresult;
64733 }
64734
64735
64736 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
64737   unsigned int jresult ;
64738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64739   bool arg2 ;
64740   bool result;
64741
64742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64743   arg2 = jarg2 ? true : false;
64744   {
64745     try {
64746       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
64747     } catch (std::out_of_range& e) {
64748       {
64749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64750       };
64751     } catch (std::exception& e) {
64752       {
64753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64754       };
64755     } catch (Dali::DaliException e) {
64756       {
64757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64758       };
64759     } catch (...) {
64760       {
64761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64762       };
64763     }
64764   }
64765
64766   jresult = result;
64767   return jresult;
64768 }
64769
64770
64771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
64772   unsigned int jresult ;
64773   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64774   bool result;
64775
64776   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64777   {
64778     try {
64779       result = (bool)(arg1)->OnAccessibilityZoom();
64780     } catch (std::out_of_range& e) {
64781       {
64782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64783       };
64784     } catch (std::exception& e) {
64785       {
64786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64787       };
64788     } catch (Dali::DaliException e) {
64789       {
64790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64791       };
64792     } catch (...) {
64793       {
64794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64795       };
64796     }
64797   }
64798
64799   jresult = result;
64800   return jresult;
64801 }
64802
64803
64804 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
64805   unsigned int jresult ;
64806   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64807   bool result;
64808
64809   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64810   {
64811     try {
64812       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
64813     } catch (std::out_of_range& e) {
64814       {
64815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64816       };
64817     } catch (std::exception& e) {
64818       {
64819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64820       };
64821     } catch (Dali::DaliException e) {
64822       {
64823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64824       };
64825     } catch (...) {
64826       {
64827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64828       };
64829     }
64830   }
64831
64832   jresult = result;
64833   return jresult;
64834 }
64835
64836
64837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
64838   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64839
64840   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64841   {
64842     try {
64843       (arg1)->OnKeyInputFocusGained();
64844     } catch (std::out_of_range& e) {
64845       {
64846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64847       };
64848     } catch (std::exception& e) {
64849       {
64850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64851       };
64852     } catch (Dali::DaliException e) {
64853       {
64854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64855       };
64856     } catch (...) {
64857       {
64858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64859       };
64860     }
64861   }
64862
64863 }
64864
64865
64866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
64867   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64868
64869   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64870   {
64871     try {
64872       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
64873     } catch (std::out_of_range& e) {
64874       {
64875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64876       };
64877     } catch (std::exception& e) {
64878       {
64879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64880       };
64881     } catch (Dali::DaliException e) {
64882       {
64883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64884       };
64885     } catch (...) {
64886       {
64887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64888       };
64889     }
64890   }
64891
64892 }
64893
64894
64895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
64896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64897
64898   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64899   {
64900     try {
64901       (arg1)->OnKeyInputFocusLost();
64902     } catch (std::out_of_range& e) {
64903       {
64904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64905       };
64906     } catch (std::exception& e) {
64907       {
64908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64909       };
64910     } catch (Dali::DaliException e) {
64911       {
64912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64913       };
64914     } catch (...) {
64915       {
64916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64917       };
64918     }
64919   }
64920
64921 }
64922
64923
64924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
64925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64926
64927   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64928   {
64929     try {
64930       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
64931     } catch (std::out_of_range& e) {
64932       {
64933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64934       };
64935     } catch (std::exception& e) {
64936       {
64937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64938       };
64939     } catch (Dali::DaliException e) {
64940       {
64941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64942       };
64943     } catch (...) {
64944       {
64945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64946       };
64947     }
64948   }
64949
64950 }
64951
64952
64953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
64954   void * jresult ;
64955   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
64956   Dali::Actor arg2 ;
64957   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
64958   bool arg4 ;
64959   Dali::Actor *argp2 ;
64960   Dali::Actor result;
64961
64962   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64963   argp2 = (Dali::Actor *)jarg2;
64964   if (!argp2) {
64965     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
64966     return 0;
64967   }
64968   arg2 = *argp2;
64969   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
64970   arg4 = jarg4 ? true : false;
64971   {
64972     try {
64973       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
64974     } catch (std::out_of_range& e) {
64975       {
64976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64977       };
64978     } catch (std::exception& e) {
64979       {
64980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64981       };
64982     } catch (Dali::DaliException e) {
64983       {
64984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64985       };
64986     } catch (...) {
64987       {
64988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64989       };
64990     }
64991   }
64992
64993   jresult = new Dali::Actor((const Dali::Actor &)result);
64994   return jresult;
64995 }
64996
64997
64998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
64999   void * jresult ;
65000   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65001   Dali::Actor arg2 ;
65002   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
65003   bool arg4 ;
65004   Dali::Actor *argp2 ;
65005   Dali::Actor result;
65006
65007   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65008   argp2 = (Dali::Actor *)jarg2;
65009   if (!argp2) {
65010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65011     return 0;
65012   }
65013   arg2 = *argp2;
65014   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
65015   arg4 = jarg4 ? true : false;
65016   {
65017     try {
65018       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
65019     } catch (std::out_of_range& e) {
65020       {
65021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65022       };
65023     } catch (std::exception& e) {
65024       {
65025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65026       };
65027     } catch (Dali::DaliException e) {
65028       {
65029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65030       };
65031     } catch (...) {
65032       {
65033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65034       };
65035     }
65036   }
65037
65038   jresult = new Dali::Actor((const Dali::Actor &)result);
65039   return jresult;
65040 }
65041
65042
65043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
65044   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65045   Dali::Actor arg2 ;
65046   Dali::Actor *argp2 ;
65047
65048   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65049   argp2 = (Dali::Actor *)jarg2;
65050   if (!argp2) {
65051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65052     return ;
65053   }
65054   arg2 = *argp2;
65055   {
65056     try {
65057       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
65058     } catch (std::out_of_range& e) {
65059       {
65060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65061       };
65062     } catch (std::exception& e) {
65063       {
65064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65065       };
65066     } catch (Dali::DaliException e) {
65067       {
65068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65069       };
65070     } catch (...) {
65071       {
65072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65073       };
65074     }
65075   }
65076
65077 }
65078
65079
65080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65082   Dali::Actor arg2 ;
65083   Dali::Actor *argp2 ;
65084
65085   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65086   argp2 = (Dali::Actor *)jarg2;
65087   if (!argp2) {
65088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
65089     return ;
65090   }
65091   arg2 = *argp2;
65092   {
65093     try {
65094       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
65095     } catch (std::out_of_range& e) {
65096       {
65097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65098       };
65099     } catch (std::exception& e) {
65100       {
65101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65102       };
65103     } catch (Dali::DaliException e) {
65104       {
65105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65106       };
65107     } catch (...) {
65108       {
65109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65110       };
65111     }
65112   }
65113
65114 }
65115
65116
65117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
65118   unsigned int jresult ;
65119   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65120   bool result;
65121
65122   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65123   {
65124     try {
65125       result = (bool)(arg1)->OnKeyboardEnter();
65126     } catch (std::out_of_range& e) {
65127       {
65128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65129       };
65130     } catch (std::exception& e) {
65131       {
65132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65133       };
65134     } catch (Dali::DaliException e) {
65135       {
65136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65137       };
65138     } catch (...) {
65139       {
65140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65141       };
65142     }
65143   }
65144
65145   jresult = result;
65146   return jresult;
65147 }
65148
65149
65150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
65151   unsigned int jresult ;
65152   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65153   bool result;
65154
65155   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65156   {
65157     try {
65158       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
65159     } catch (std::out_of_range& e) {
65160       {
65161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65162       };
65163     } catch (std::exception& e) {
65164       {
65165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65166       };
65167     } catch (Dali::DaliException e) {
65168       {
65169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65170       };
65171     } catch (...) {
65172       {
65173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65174       };
65175     }
65176   }
65177
65178   jresult = result;
65179   return jresult;
65180 }
65181
65182
65183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
65184   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65185   Dali::PinchGesture *arg2 = 0 ;
65186
65187   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65188   arg2 = (Dali::PinchGesture *)jarg2;
65189   if (!arg2) {
65190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
65191     return ;
65192   }
65193   {
65194     try {
65195       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
65196     } catch (std::out_of_range& e) {
65197       {
65198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65199       };
65200     } catch (std::exception& e) {
65201       {
65202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65203       };
65204     } catch (Dali::DaliException e) {
65205       {
65206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65207       };
65208     } catch (...) {
65209       {
65210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65211       };
65212     }
65213   }
65214
65215 }
65216
65217
65218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65219   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65220   Dali::PinchGesture *arg2 = 0 ;
65221
65222   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65223   arg2 = (Dali::PinchGesture *)jarg2;
65224   if (!arg2) {
65225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
65226     return ;
65227   }
65228   {
65229     try {
65230       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
65231     } catch (std::out_of_range& e) {
65232       {
65233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65234       };
65235     } catch (std::exception& e) {
65236       {
65237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65238       };
65239     } catch (Dali::DaliException e) {
65240       {
65241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65242       };
65243     } catch (...) {
65244       {
65245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65246       };
65247     }
65248   }
65249
65250 }
65251
65252
65253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
65254   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65255   Dali::PanGesture *arg2 = 0 ;
65256
65257   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65258   arg2 = (Dali::PanGesture *)jarg2;
65259   if (!arg2) {
65260     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
65261     return ;
65262   }
65263   {
65264     try {
65265       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
65266     } catch (std::out_of_range& e) {
65267       {
65268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65269       };
65270     } catch (std::exception& e) {
65271       {
65272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65273       };
65274     } catch (Dali::DaliException e) {
65275       {
65276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65277       };
65278     } catch (...) {
65279       {
65280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65281       };
65282     }
65283   }
65284
65285 }
65286
65287
65288 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65289   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65290   Dali::PanGesture *arg2 = 0 ;
65291
65292   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65293   arg2 = (Dali::PanGesture *)jarg2;
65294   if (!arg2) {
65295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
65296     return ;
65297   }
65298   {
65299     try {
65300       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
65301     } catch (std::out_of_range& e) {
65302       {
65303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65304       };
65305     } catch (std::exception& e) {
65306       {
65307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65308       };
65309     } catch (Dali::DaliException e) {
65310       {
65311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65312       };
65313     } catch (...) {
65314       {
65315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65316       };
65317     }
65318   }
65319
65320 }
65321
65322
65323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
65324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65325   Dali::TapGesture *arg2 = 0 ;
65326
65327   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65328   arg2 = (Dali::TapGesture *)jarg2;
65329   if (!arg2) {
65330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
65331     return ;
65332   }
65333   {
65334     try {
65335       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
65336     } catch (std::out_of_range& e) {
65337       {
65338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65339       };
65340     } catch (std::exception& e) {
65341       {
65342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65343       };
65344     } catch (Dali::DaliException e) {
65345       {
65346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65347       };
65348     } catch (...) {
65349       {
65350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65351       };
65352     }
65353   }
65354
65355 }
65356
65357
65358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65360   Dali::TapGesture *arg2 = 0 ;
65361
65362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65363   arg2 = (Dali::TapGesture *)jarg2;
65364   if (!arg2) {
65365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
65366     return ;
65367   }
65368   {
65369     try {
65370       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
65371     } catch (std::out_of_range& e) {
65372       {
65373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65374       };
65375     } catch (std::exception& e) {
65376       {
65377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65378       };
65379     } catch (Dali::DaliException e) {
65380       {
65381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65382       };
65383     } catch (...) {
65384       {
65385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65386       };
65387     }
65388   }
65389
65390 }
65391
65392
65393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
65394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65395   Dali::LongPressGesture *arg2 = 0 ;
65396
65397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65398   arg2 = (Dali::LongPressGesture *)jarg2;
65399   if (!arg2) {
65400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
65401     return ;
65402   }
65403   {
65404     try {
65405       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
65406     } catch (std::out_of_range& e) {
65407       {
65408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65409       };
65410     } catch (std::exception& e) {
65411       {
65412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65413       };
65414     } catch (Dali::DaliException e) {
65415       {
65416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65417       };
65418     } catch (...) {
65419       {
65420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65421       };
65422     }
65423   }
65424
65425 }
65426
65427
65428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
65429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65430   Dali::LongPressGesture *arg2 = 0 ;
65431
65432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65433   arg2 = (Dali::LongPressGesture *)jarg2;
65434   if (!arg2) {
65435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
65436     return ;
65437   }
65438   {
65439     try {
65440       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
65441     } catch (std::out_of_range& e) {
65442       {
65443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65444       };
65445     } catch (std::exception& e) {
65446       {
65447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65448       };
65449     } catch (Dali::DaliException e) {
65450       {
65451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65452       };
65453     } catch (...) {
65454       {
65455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65456       };
65457     }
65458   }
65459
65460 }
65461
65462
65463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
65464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65465   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
65466   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
65467
65468   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65469   arg2 = (Dali::SlotObserver *)jarg2;
65470   arg3 = (Dali::CallbackBase *)jarg3;
65471   {
65472     try {
65473       (arg1)->SignalConnected(arg2,arg3);
65474     } catch (std::out_of_range& e) {
65475       {
65476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65477       };
65478     } catch (std::exception& e) {
65479       {
65480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65481       };
65482     } catch (Dali::DaliException e) {
65483       {
65484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65485       };
65486     } catch (...) {
65487       {
65488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65489       };
65490     }
65491   }
65492
65493 }
65494
65495
65496 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65497   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65498   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
65499   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
65500
65501   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65502   arg2 = (Dali::SlotObserver *)jarg2;
65503   arg3 = (Dali::CallbackBase *)jarg3;
65504   {
65505     try {
65506       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
65507     } catch (std::out_of_range& e) {
65508       {
65509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65510       };
65511     } catch (std::exception& e) {
65512       {
65513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65514       };
65515     } catch (Dali::DaliException e) {
65516       {
65517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65518       };
65519     } catch (...) {
65520       {
65521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65522       };
65523     }
65524   }
65525
65526 }
65527
65528
65529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
65530   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65531   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
65532   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
65533
65534   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65535   arg2 = (Dali::SlotObserver *)jarg2;
65536   arg3 = (Dali::CallbackBase *)jarg3;
65537   {
65538     try {
65539       (arg1)->SignalDisconnected(arg2,arg3);
65540     } catch (std::out_of_range& e) {
65541       {
65542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65543       };
65544     } catch (std::exception& e) {
65545       {
65546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65547       };
65548     } catch (Dali::DaliException e) {
65549       {
65550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65551       };
65552     } catch (...) {
65553       {
65554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65555       };
65556     }
65557   }
65558
65559 }
65560
65561
65562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
65563   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
65564   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
65565   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
65566
65567   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
65568   arg2 = (Dali::SlotObserver *)jarg2;
65569   arg3 = (Dali::CallbackBase *)jarg3;
65570   {
65571     try {
65572       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
65573     } catch (std::out_of_range& e) {
65574       {
65575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65576       };
65577     } catch (std::exception& e) {
65578       {
65579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65580       };
65581     } catch (Dali::DaliException e) {
65582       {
65583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65584       };
65585     } catch (...) {
65586       {
65587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65588       };
65589     }
65590   }
65591
65592 }
65593
65594
65595 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) {
65596   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
65597   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
65598   if (director) {
65599     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);
65600   }
65601 }
65602
65603
65604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
65605   void * jresult ;
65606   Dali::Toolkit::Control *arg1 = 0 ;
65607   Dali::Toolkit::Internal::Control *result = 0 ;
65608
65609   arg1 = (Dali::Toolkit::Control *)jarg1;
65610   if (!arg1) {
65611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
65612     return 0;
65613   }
65614   {
65615     try {
65616       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
65617     } catch (std::out_of_range& e) {
65618       {
65619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65620       };
65621     } catch (std::exception& e) {
65622       {
65623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65624       };
65625     } catch (Dali::DaliException e) {
65626       {
65627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65628       };
65629     } catch (...) {
65630       {
65631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65632       };
65633     }
65634   }
65635
65636   jresult = (void *)result;
65637   return jresult;
65638 }
65639
65640
65641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
65642   int jresult ;
65643   int result;
65644
65645   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
65646   jresult = (int)result;
65647   return jresult;
65648 }
65649
65650 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
65651   int jresult ;
65652   int result;
65653
65654   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
65655   jresult = (int)result;
65656   return jresult;
65657 }
65658
65659
65660 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
65661   int jresult ;
65662   int result;
65663
65664   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
65665   jresult = (int)result;
65666   return jresult;
65667 }
65668
65669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
65670   int jresult ;
65671   int result;
65672
65673   result = (int)Dali::Toolkit::Control::Property::MARGIN;
65674   jresult = (int)result;
65675   return jresult;
65676 }
65677
65678
65679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
65680   int jresult ;
65681   int result;
65682
65683   result = (int)Dali::Toolkit::Control::Property::PADDING;
65684   jresult = (int)result;
65685   return jresult;
65686 }
65687
65688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
65689   int jresult ;
65690   int result;
65691
65692   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
65693   jresult = (int)result;
65694   return jresult;
65695 }
65696
65697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
65698   void * jresult ;
65699   Dali::Toolkit::Control::Property *result = 0 ;
65700
65701   {
65702     try {
65703       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
65704     } catch (std::out_of_range& e) {
65705       {
65706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65707       };
65708     } catch (std::exception& e) {
65709       {
65710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65711       };
65712     } catch (Dali::DaliException e) {
65713       {
65714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65715       };
65716     } catch (...) {
65717       {
65718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65719       };
65720     }
65721   }
65722
65723   jresult = (void *)result;
65724   return jresult;
65725 }
65726
65727
65728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
65729   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
65730
65731   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
65732   {
65733     try {
65734       delete arg1;
65735     } catch (std::out_of_range& e) {
65736       {
65737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65738       };
65739     } catch (std::exception& e) {
65740       {
65741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65742       };
65743     } catch (Dali::DaliException e) {
65744       {
65745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65746       };
65747     } catch (...) {
65748       {
65749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65750       };
65751     }
65752   }
65753
65754 }
65755
65756
65757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
65758   void * jresult ;
65759   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
65760
65761   {
65762     try {
65763       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
65764     } catch (std::out_of_range& e) {
65765       {
65766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65767       };
65768     } catch (std::exception& e) {
65769       {
65770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65771       };
65772     } catch (Dali::DaliException e) {
65773       {
65774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65775       };
65776     } catch (...) {
65777       {
65778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65779       };
65780     }
65781   }
65782
65783   jresult = (void *)result;
65784   return jresult;
65785 }
65786
65787
65788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
65789   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
65790
65791   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
65792   {
65793     try {
65794       delete arg1;
65795     } catch (std::out_of_range& e) {
65796       {
65797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65798       };
65799     } catch (std::exception& e) {
65800       {
65801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65802       };
65803     } catch (Dali::DaliException e) {
65804       {
65805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65806       };
65807     } catch (...) {
65808       {
65809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65810       };
65811     }
65812   }
65813
65814 }
65815
65816
65817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
65818   void * jresult ;
65819   Dali::Toolkit::Control result;
65820
65821   {
65822     try {
65823       result = Dali::Toolkit::Control::New();
65824     } catch (std::out_of_range& e) {
65825       {
65826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65827       };
65828     } catch (std::exception& e) {
65829       {
65830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65831       };
65832     } catch (Dali::DaliException e) {
65833       {
65834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65835       };
65836     } catch (...) {
65837       {
65838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65839       };
65840     }
65841   }
65842
65843   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
65844   return jresult;
65845 }
65846
65847
65848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
65849   void * jresult ;
65850   Dali::Toolkit::Control *result = 0 ;
65851
65852   {
65853     try {
65854       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
65855     } catch (std::out_of_range& e) {
65856       {
65857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65858       };
65859     } catch (std::exception& e) {
65860       {
65861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65862       };
65863     } catch (Dali::DaliException e) {
65864       {
65865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65866       };
65867     } catch (...) {
65868       {
65869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65870       };
65871     }
65872   }
65873
65874   jresult = (void *)result;
65875   return jresult;
65876 }
65877
65878
65879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
65880   void * jresult ;
65881   Dali::Toolkit::Control *arg1 = 0 ;
65882   Dali::Toolkit::Control *result = 0 ;
65883
65884   arg1 = (Dali::Toolkit::Control *)jarg1;
65885   if (!arg1) {
65886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
65887     return 0;
65888   }
65889   {
65890     try {
65891       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
65892     } catch (std::out_of_range& e) {
65893       {
65894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65895       };
65896     } catch (std::exception& e) {
65897       {
65898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65899       };
65900     } catch (Dali::DaliException e) {
65901       {
65902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65903       };
65904     } catch (...) {
65905       {
65906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65907       };
65908     }
65909   }
65910
65911   jresult = (void *)result;
65912   return jresult;
65913 }
65914
65915
65916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
65917   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65918
65919   arg1 = (Dali::Toolkit::Control *)jarg1;
65920   {
65921     try {
65922       delete arg1;
65923     } catch (std::out_of_range& e) {
65924       {
65925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65926       };
65927     } catch (std::exception& e) {
65928       {
65929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65930       };
65931     } catch (Dali::DaliException e) {
65932       {
65933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65934       };
65935     } catch (...) {
65936       {
65937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65938       };
65939     }
65940   }
65941
65942 }
65943
65944
65945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
65946   void * jresult ;
65947   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
65948   Dali::Toolkit::Control *arg2 = 0 ;
65949   Dali::Toolkit::Control *result = 0 ;
65950
65951   arg1 = (Dali::Toolkit::Control *)jarg1;
65952   arg2 = (Dali::Toolkit::Control *)jarg2;
65953   if (!arg2) {
65954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
65955     return 0;
65956   }
65957   {
65958     try {
65959       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
65960     } catch (std::out_of_range& e) {
65961       {
65962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65963       };
65964     } catch (std::exception& e) {
65965       {
65966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65967       };
65968     } catch (Dali::DaliException e) {
65969       {
65970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65971       };
65972     } catch (...) {
65973       {
65974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65975       };
65976     }
65977   }
65978
65979   jresult = (void *)result;
65980   return jresult;
65981 }
65982
65983
65984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
65985   void * jresult ;
65986   Dali::BaseHandle arg1 ;
65987   Dali::BaseHandle *argp1 ;
65988   Dali::Toolkit::Control result;
65989
65990   argp1 = (Dali::BaseHandle *)jarg1;
65991   if (!argp1) {
65992     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65993     return 0;
65994   }
65995   arg1 = *argp1;
65996   {
65997     try {
65998       result = Dali::Toolkit::Control::DownCast(arg1);
65999     } catch (std::out_of_range& e) {
66000       {
66001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66002       };
66003     } catch (std::exception& e) {
66004       {
66005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66006       };
66007     } catch (Dali::DaliException e) {
66008       {
66009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66010       };
66011     } catch (...) {
66012       {
66013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66014       };
66015     }
66016   }
66017
66018   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
66019   return jresult;
66020 }
66021
66022
66023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
66024   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66025
66026   arg1 = (Dali::Toolkit::Control *)jarg1;
66027   {
66028     try {
66029       (arg1)->SetKeyInputFocus();
66030     } catch (std::out_of_range& e) {
66031       {
66032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66033       };
66034     } catch (std::exception& e) {
66035       {
66036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66037       };
66038     } catch (Dali::DaliException e) {
66039       {
66040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66041       };
66042     } catch (...) {
66043       {
66044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66045       };
66046     }
66047   }
66048
66049 }
66050
66051
66052 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
66053   unsigned int jresult ;
66054   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66055   bool result;
66056
66057   arg1 = (Dali::Toolkit::Control *)jarg1;
66058   {
66059     try {
66060       result = (bool)(arg1)->HasKeyInputFocus();
66061     } catch (std::out_of_range& e) {
66062       {
66063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66064       };
66065     } catch (std::exception& e) {
66066       {
66067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66068       };
66069     } catch (Dali::DaliException e) {
66070       {
66071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66072       };
66073     } catch (...) {
66074       {
66075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66076       };
66077     }
66078   }
66079
66080   jresult = result;
66081   return jresult;
66082 }
66083
66084
66085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
66086   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66087
66088   arg1 = (Dali::Toolkit::Control *)jarg1;
66089   {
66090     try {
66091       (arg1)->ClearKeyInputFocus();
66092     } catch (std::out_of_range& e) {
66093       {
66094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66095       };
66096     } catch (std::exception& e) {
66097       {
66098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66099       };
66100     } catch (Dali::DaliException e) {
66101       {
66102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66103       };
66104     } catch (...) {
66105       {
66106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66107       };
66108     }
66109   }
66110
66111 }
66112
66113
66114 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
66115   void * jresult ;
66116   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66117   Dali::PinchGestureDetector result;
66118
66119   arg1 = (Dali::Toolkit::Control *)jarg1;
66120   {
66121     try {
66122       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
66123     } catch (std::out_of_range& e) {
66124       {
66125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66126       };
66127     } catch (std::exception& e) {
66128       {
66129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66130       };
66131     } catch (Dali::DaliException e) {
66132       {
66133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66134       };
66135     } catch (...) {
66136       {
66137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66138       };
66139     }
66140   }
66141
66142   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
66143   return jresult;
66144 }
66145
66146
66147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
66148   void * jresult ;
66149   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66150   Dali::PanGestureDetector result;
66151
66152   arg1 = (Dali::Toolkit::Control *)jarg1;
66153   {
66154     try {
66155       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
66156     } catch (std::out_of_range& e) {
66157       {
66158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66159       };
66160     } catch (std::exception& e) {
66161       {
66162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66163       };
66164     } catch (Dali::DaliException e) {
66165       {
66166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66167       };
66168     } catch (...) {
66169       {
66170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66171       };
66172     }
66173   }
66174
66175   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
66176   return jresult;
66177 }
66178
66179
66180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
66181   void * jresult ;
66182   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66183   Dali::TapGestureDetector result;
66184
66185   arg1 = (Dali::Toolkit::Control *)jarg1;
66186   {
66187     try {
66188       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
66189     } catch (std::out_of_range& e) {
66190       {
66191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66192       };
66193     } catch (std::exception& e) {
66194       {
66195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66196       };
66197     } catch (Dali::DaliException e) {
66198       {
66199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66200       };
66201     } catch (...) {
66202       {
66203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66204       };
66205     }
66206   }
66207
66208   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
66209   return jresult;
66210 }
66211
66212
66213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
66214   void * jresult ;
66215   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66216   Dali::LongPressGestureDetector result;
66217
66218   arg1 = (Dali::Toolkit::Control *)jarg1;
66219   {
66220     try {
66221       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
66222     } catch (std::out_of_range& e) {
66223       {
66224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66225       };
66226     } catch (std::exception& e) {
66227       {
66228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66229       };
66230     } catch (Dali::DaliException e) {
66231       {
66232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66233       };
66234     } catch (...) {
66235       {
66236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66237       };
66238     }
66239   }
66240
66241   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
66242   return jresult;
66243 }
66244
66245
66246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
66247   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66248   std::string *arg2 = 0 ;
66249
66250   arg1 = (Dali::Toolkit::Control *)jarg1;
66251   if (!jarg2) {
66252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66253     return ;
66254   }
66255   std::string arg2_str(jarg2);
66256   arg2 = &arg2_str;
66257   {
66258     try {
66259       (arg1)->SetStyleName((std::string const &)*arg2);
66260     } catch (std::out_of_range& e) {
66261       {
66262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66263       };
66264     } catch (std::exception& e) {
66265       {
66266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66267       };
66268     } catch (Dali::DaliException e) {
66269       {
66270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66271       };
66272     } catch (...) {
66273       {
66274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66275       };
66276     }
66277   }
66278
66279
66280   //argout typemap for const std::string&
66281
66282 }
66283
66284
66285 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
66286   char * jresult ;
66287   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66288   std::string *result = 0 ;
66289
66290   arg1 = (Dali::Toolkit::Control *)jarg1;
66291   {
66292     try {
66293       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
66294     } catch (std::out_of_range& e) {
66295       {
66296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66297       };
66298     } catch (std::exception& e) {
66299       {
66300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66301       };
66302     } catch (Dali::DaliException e) {
66303       {
66304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66305       };
66306     } catch (...) {
66307       {
66308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66309       };
66310     }
66311   }
66312
66313   jresult = SWIG_csharp_string_callback(result->c_str());
66314   return jresult;
66315 }
66316
66317
66318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
66319   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66320   Dali::Vector4 *arg2 = 0 ;
66321
66322   arg1 = (Dali::Toolkit::Control *)jarg1;
66323   arg2 = (Dali::Vector4 *)jarg2;
66324   if (!arg2) {
66325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
66326     return ;
66327   }
66328   {
66329     try {
66330       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
66331     } catch (std::out_of_range& e) {
66332       {
66333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66334       };
66335     } catch (std::exception& e) {
66336       {
66337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66338       };
66339     } catch (Dali::DaliException e) {
66340       {
66341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66342       };
66343     } catch (...) {
66344       {
66345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66346       };
66347     }
66348   }
66349
66350 }
66351
66352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
66353   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66354
66355   arg1 = (Dali::Toolkit::Control *)jarg1;
66356   {
66357     try {
66358       (arg1)->ClearBackground();
66359     } catch (std::out_of_range& e) {
66360       {
66361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66362       };
66363     } catch (std::exception& e) {
66364       {
66365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66366       };
66367     } catch (Dali::DaliException e) {
66368       {
66369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66370       };
66371     } catch (...) {
66372       {
66373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66374       };
66375     }
66376   }
66377
66378 }
66379
66380
66381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
66382   void * jresult ;
66383   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66384   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
66385
66386   arg1 = (Dali::Toolkit::Control *)jarg1;
66387   {
66388     try {
66389       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
66390     } catch (std::out_of_range& e) {
66391       {
66392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66393       };
66394     } catch (std::exception& e) {
66395       {
66396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66397       };
66398     } catch (Dali::DaliException e) {
66399       {
66400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66401       };
66402     } catch (...) {
66403       {
66404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66405       };
66406     }
66407   }
66408
66409   jresult = (void *)result;
66410   return jresult;
66411 }
66412
66413
66414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
66415   void * jresult ;
66416   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66417   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
66418
66419   arg1 = (Dali::Toolkit::Control *)jarg1;
66420   {
66421     try {
66422       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
66423     } catch (std::out_of_range& e) {
66424       {
66425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66426       };
66427     } catch (std::exception& e) {
66428       {
66429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66430       };
66431     } catch (Dali::DaliException e) {
66432       {
66433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66434       };
66435     } catch (...) {
66436       {
66437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66438       };
66439     }
66440   }
66441
66442   jresult = (void *)result;
66443   return jresult;
66444 }
66445
66446
66447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
66448   void * jresult ;
66449   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66450   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
66451
66452   arg1 = (Dali::Toolkit::Control *)jarg1;
66453   {
66454     try {
66455       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
66456     } catch (std::out_of_range& e) {
66457       {
66458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66459       };
66460     } catch (std::exception& e) {
66461       {
66462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66463       };
66464     } catch (Dali::DaliException e) {
66465       {
66466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66467       };
66468     } catch (...) {
66469       {
66470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66471       };
66472     }
66473   }
66474
66475   jresult = (void *)result;
66476   return jresult;
66477 }
66478
66479
66480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
66481   void * jresult ;
66482   Dali::Toolkit::Internal::Control *arg1 = 0 ;
66483   Dali::Toolkit::Control *result = 0 ;
66484
66485   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
66486   if (!arg1) {
66487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
66488     return 0;
66489   }
66490   {
66491     try {
66492       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
66493     } catch (std::out_of_range& e) {
66494       {
66495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66496       };
66497     } catch (std::exception& e) {
66498       {
66499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66500       };
66501     } catch (Dali::DaliException e) {
66502       {
66503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66504       };
66505     } catch (...) {
66506       {
66507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66508       };
66509     }
66510   }
66511
66512   jresult = (void *)result;
66513   return jresult;
66514 }
66515
66516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
66517 {
66518   int jresult;
66519   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66520   arg1 = (Dali::Toolkit::Control *)jarg1;
66521
66522   if (!arg1) {
66523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66524     return 0;
66525   }
66526
66527   Dali::Property::Index arg2 = 0 ;
66528   arg2 = (Dali::Property::Index)jarg2;
66529
66530   Toolkit::Visual::ResourceStatus result;
66531   {
66532     try {
66533       result = arg1->GetVisualResourceStatus(arg2);
66534     } catch (std::out_of_range& e) {
66535       {
66536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66537       };
66538     } catch (std::exception& e) {
66539       {
66540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66541       };
66542     } catch (...) {
66543       {
66544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66545       };
66546     }
66547   }
66548   jresult = (int)(result);
66549   return jresult;
66550 }
66551
66552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
66553 {
66554   void * jresult;
66555   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
66556   arg1 = (Dali::Toolkit::Control *)jarg1;
66557
66558   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
66559
66560   Dali::Toolkit::TransitionData *arg2 = 0 ;
66561   Dali::Animation result;
66562
66563   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
66564   if (!arg2) {
66565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
66566     return 0;
66567   }
66568   {
66569     try {
66570       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
66571     } catch (std::out_of_range& e) {
66572       {
66573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66574       };
66575     } catch (std::exception& e) {
66576       {
66577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66578       };
66579     } catch (Dali::DaliException e) {
66580       {
66581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66582       };
66583     } catch (...) {
66584       {
66585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66586       };
66587     }
66588   }
66589
66590   jresult = new Dali::Animation((const Dali::Animation &)result);
66591   return jresult;
66592 }
66593
66594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
66595 {
66596   Dali::Toolkit::Control arg1;
66597   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
66598
66599   if (!argp1) {
66600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66601   }
66602   arg1 = *argp1;
66603
66604   Dali::Property::Index arg2 = 0 ;
66605   arg2 = (Dali::Property::Index)jarg2;
66606
66607   Dali::Property::Index arg3 = 0 ;
66608   arg3 = (Dali::Property::Index)jarg3;
66609
66610   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
66611
66612   {
66613     try {
66614       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
66615     } catch (std::out_of_range& e) {
66616       {
66617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66618       };
66619     } catch (std::exception& e) {
66620       {
66621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66622       };
66623     } catch (...) {
66624       {
66625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66626       };
66627     }
66628   }
66629
66630
66631 }
66632
66633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
66634   void * jresult ;
66635   Dali::Toolkit::Control *arg1 = 0 ;
66636   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
66637
66638   arg1 = (Dali::Toolkit::Control *)jarg1;
66639   if (!arg1) {
66640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
66641     return 0;
66642   }
66643   {
66644     try {
66645       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
66646     } catch (std::out_of_range& e) {
66647       {
66648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66649       };
66650     } catch (std::exception& e) {
66651       {
66652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66653       };
66654     } catch (Dali::DaliException e) {
66655       {
66656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66657       };
66658     } catch (...) {
66659       {
66660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66661       };
66662     }
66663   }
66664
66665   jresult = (void *)result;
66666   return jresult;
66667 }
66668
66669
66670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
66671   unsigned int jresult ;
66672   Dali::Toolkit::Control *arg1 = 0 ;
66673   bool result;
66674
66675   arg1 = (Dali::Toolkit::Control *)jarg1;
66676   if (!arg1) {
66677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
66678     return 0;
66679   }
66680   {
66681     try {
66682       result = (bool)arg1->IsResourceReady();
66683     } catch (std::out_of_range& e) {
66684       {
66685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66686       };
66687     } catch (std::exception& e) {
66688       {
66689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66690       };
66691     } catch (Dali::DaliException e) {
66692       {
66693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66694       };
66695     } catch (...) {
66696       {
66697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66698       };
66699     }
66700   }
66701
66702   jresult = result;
66703   return jresult;
66704 }
66705
66706
66707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
66708   void * jresult ;
66709   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
66710
66711   {
66712     try {
66713       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
66714     } catch (std::out_of_range& e) {
66715       {
66716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66717       };
66718     } catch (std::exception& e) {
66719       {
66720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66721       };
66722     } catch (Dali::DaliException e) {
66723       {
66724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66725       };
66726     } catch (...) {
66727       {
66728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66729       };
66730     }
66731   }
66732
66733   jresult = (void *)result;
66734   return jresult;
66735 }
66736
66737
66738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
66739   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
66740
66741   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
66742   {
66743     try {
66744       delete arg1;
66745     } catch (std::out_of_range& e) {
66746       {
66747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66748       };
66749     } catch (std::exception& e) {
66750       {
66751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66752       };
66753     } catch (Dali::DaliException e) {
66754       {
66755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66756       };
66757     } catch (...) {
66758       {
66759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66760       };
66761     }
66762   }
66763
66764 }
66765
66766
66767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
66768   void * jresult ;
66769   Dali::Toolkit::KeyInputFocusManager result;
66770
66771   {
66772     try {
66773       result = Dali::Toolkit::KeyInputFocusManager::Get();
66774     } catch (std::out_of_range& e) {
66775       {
66776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66777       };
66778     } catch (std::exception& e) {
66779       {
66780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66781       };
66782     } catch (Dali::DaliException e) {
66783       {
66784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66785       };
66786     } catch (...) {
66787       {
66788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66789       };
66790     }
66791   }
66792
66793   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
66794   return jresult;
66795 }
66796
66797
66798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
66799   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
66800   Dali::Toolkit::Control arg2 ;
66801   Dali::Toolkit::Control *argp2 ;
66802
66803   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
66804   argp2 = (Dali::Toolkit::Control *)jarg2;
66805   if (!argp2) {
66806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
66807     return ;
66808   }
66809   arg2 = *argp2;
66810   {
66811     try {
66812       (arg1)->SetFocus(arg2);
66813     } catch (std::out_of_range& e) {
66814       {
66815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66816       };
66817     } catch (std::exception& e) {
66818       {
66819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66820       };
66821     } catch (Dali::DaliException e) {
66822       {
66823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66824       };
66825     } catch (...) {
66826       {
66827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66828       };
66829     }
66830   }
66831
66832 }
66833
66834
66835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
66836   void * jresult ;
66837   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
66838   Dali::Toolkit::Control result;
66839
66840   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
66841   {
66842     try {
66843       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
66844     } catch (std::out_of_range& e) {
66845       {
66846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66847       };
66848     } catch (std::exception& e) {
66849       {
66850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66851       };
66852     } catch (Dali::DaliException e) {
66853       {
66854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66855       };
66856     } catch (...) {
66857       {
66858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66859       };
66860     }
66861   }
66862
66863   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
66864   return jresult;
66865 }
66866
66867
66868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
66869   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
66870   Dali::Toolkit::Control arg2 ;
66871   Dali::Toolkit::Control *argp2 ;
66872
66873   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
66874   argp2 = (Dali::Toolkit::Control *)jarg2;
66875   if (!argp2) {
66876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
66877     return ;
66878   }
66879   arg2 = *argp2;
66880   {
66881     try {
66882       (arg1)->RemoveFocus(arg2);
66883     } catch (std::out_of_range& e) {
66884       {
66885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66886       };
66887     } catch (std::exception& e) {
66888       {
66889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66890       };
66891     } catch (Dali::DaliException e) {
66892       {
66893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66894       };
66895     } catch (...) {
66896       {
66897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66898       };
66899     }
66900   }
66901
66902 }
66903
66904
66905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
66906   void * jresult ;
66907   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
66908   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
66909
66910   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
66911   {
66912     try {
66913       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
66914     } catch (std::out_of_range& e) {
66915       {
66916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66917       };
66918     } catch (std::exception& e) {
66919       {
66920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66921       };
66922     } catch (Dali::DaliException e) {
66923       {
66924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66925       };
66926     } catch (...) {
66927       {
66928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66929       };
66930     }
66931   }
66932
66933   jresult = (void *)result;
66934   return jresult;
66935 }
66936
66937
66938 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
66939   void * jresult ;
66940   Dali::Toolkit::Alignment::Padding *result = 0 ;
66941
66942   {
66943     try {
66944       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
66945     } catch (std::out_of_range& e) {
66946       {
66947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66948       };
66949     } catch (std::exception& e) {
66950       {
66951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66952       };
66953     } catch (Dali::DaliException e) {
66954       {
66955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66956       };
66957     } catch (...) {
66958       {
66959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66960       };
66961     }
66962   }
66963
66964   jresult = (void *)result;
66965   return jresult;
66966 }
66967
66968
66969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
66970   void * jresult ;
66971   float arg1 ;
66972   float arg2 ;
66973   float arg3 ;
66974   float arg4 ;
66975   Dali::Toolkit::Alignment::Padding *result = 0 ;
66976
66977   arg1 = (float)jarg1;
66978   arg2 = (float)jarg2;
66979   arg3 = (float)jarg3;
66980   arg4 = (float)jarg4;
66981   {
66982     try {
66983       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
66984     } catch (std::out_of_range& e) {
66985       {
66986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66987       };
66988     } catch (std::exception& e) {
66989       {
66990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66991       };
66992     } catch (Dali::DaliException e) {
66993       {
66994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66995       };
66996     } catch (...) {
66997       {
66998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66999       };
67000     }
67001   }
67002
67003   jresult = (void *)result;
67004   return jresult;
67005 }
67006
67007
67008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
67009   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
67010   float arg2 ;
67011
67012   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
67013   arg2 = (float)jarg2;
67014   if (arg1) (arg1)->left = arg2;
67015 }
67016
67017
67018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
67019   float jresult ;
67020   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
67021   float result;
67022
67023   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
67024   result = (float) ((arg1)->left);
67025   jresult = result;
67026   return jresult;
67027 }
67028
67029
67030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
67031   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
67032   float arg2 ;
67033
67034   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
67035   arg2 = (float)jarg2;
67036   if (arg1) (arg1)->right = arg2;
67037 }
67038
67039
67040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
67041   float jresult ;
67042   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
67043   float result;
67044
67045   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
67046   result = (float) ((arg1)->right);
67047   jresult = result;
67048   return jresult;
67049 }
67050
67051
67052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
67053   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
67054   float arg2 ;
67055
67056   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
67057   arg2 = (float)jarg2;
67058   if (arg1) (arg1)->top = arg2;
67059 }
67060
67061
67062 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
67063   float jresult ;
67064   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
67065   float result;
67066
67067   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
67068   result = (float) ((arg1)->top);
67069   jresult = result;
67070   return jresult;
67071 }
67072
67073
67074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
67075   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
67076   float arg2 ;
67077
67078   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
67079   arg2 = (float)jarg2;
67080   if (arg1) (arg1)->bottom = arg2;
67081 }
67082
67083
67084 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
67085   float jresult ;
67086   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
67087   float result;
67088
67089   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
67090   result = (float) ((arg1)->bottom);
67091   jresult = result;
67092   return jresult;
67093 }
67094
67095
67096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
67097   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
67098
67099   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
67100   {
67101     try {
67102       delete arg1;
67103     } catch (std::out_of_range& e) {
67104       {
67105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67106       };
67107     } catch (std::exception& e) {
67108       {
67109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67110       };
67111     } catch (Dali::DaliException e) {
67112       {
67113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67114       };
67115     } catch (...) {
67116       {
67117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67118       };
67119     }
67120   }
67121
67122 }
67123
67124
67125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
67126   void * jresult ;
67127   Dali::Toolkit::Alignment *result = 0 ;
67128
67129   {
67130     try {
67131       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
67132     } catch (std::out_of_range& e) {
67133       {
67134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67135       };
67136     } catch (std::exception& e) {
67137       {
67138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67139       };
67140     } catch (Dali::DaliException e) {
67141       {
67142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67143       };
67144     } catch (...) {
67145       {
67146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67147       };
67148     }
67149   }
67150
67151   jresult = (void *)result;
67152   return jresult;
67153 }
67154
67155
67156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
67157   void * jresult ;
67158   Dali::Toolkit::Alignment::Type arg1 ;
67159   Dali::Toolkit::Alignment::Type arg2 ;
67160   Dali::Toolkit::Alignment result;
67161
67162   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
67163   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
67164   {
67165     try {
67166       result = Dali::Toolkit::Alignment::New(arg1,arg2);
67167     } catch (std::out_of_range& e) {
67168       {
67169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67170       };
67171     } catch (std::exception& e) {
67172       {
67173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67174       };
67175     } catch (Dali::DaliException e) {
67176       {
67177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67178       };
67179     } catch (...) {
67180       {
67181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67182       };
67183     }
67184   }
67185
67186   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
67187   return jresult;
67188 }
67189
67190
67191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
67192   void * jresult ;
67193   Dali::Toolkit::Alignment::Type arg1 ;
67194   Dali::Toolkit::Alignment result;
67195
67196   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
67197   {
67198     try {
67199       result = Dali::Toolkit::Alignment::New(arg1);
67200     } catch (std::out_of_range& e) {
67201       {
67202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67203       };
67204     } catch (std::exception& e) {
67205       {
67206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67207       };
67208     } catch (Dali::DaliException e) {
67209       {
67210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67211       };
67212     } catch (...) {
67213       {
67214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67215       };
67216     }
67217   }
67218
67219   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
67220   return jresult;
67221 }
67222
67223
67224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
67225   void * jresult ;
67226   Dali::Toolkit::Alignment result;
67227
67228   {
67229     try {
67230       result = Dali::Toolkit::Alignment::New();
67231     } catch (std::out_of_range& e) {
67232       {
67233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67234       };
67235     } catch (std::exception& e) {
67236       {
67237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67238       };
67239     } catch (Dali::DaliException e) {
67240       {
67241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67242       };
67243     } catch (...) {
67244       {
67245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67246       };
67247     }
67248   }
67249
67250   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
67251   return jresult;
67252 }
67253
67254
67255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
67256   void * jresult ;
67257   Dali::Toolkit::Alignment *arg1 = 0 ;
67258   Dali::Toolkit::Alignment *result = 0 ;
67259
67260   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67261   if (!arg1) {
67262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
67263     return 0;
67264   }
67265   {
67266     try {
67267       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
67268     } catch (std::out_of_range& e) {
67269       {
67270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67271       };
67272     } catch (std::exception& e) {
67273       {
67274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67275       };
67276     } catch (Dali::DaliException e) {
67277       {
67278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67279       };
67280     } catch (...) {
67281       {
67282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67283       };
67284     }
67285   }
67286
67287   jresult = (void *)result;
67288   return jresult;
67289 }
67290
67291
67292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
67293   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
67294
67295   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67296   {
67297     try {
67298       delete arg1;
67299     } catch (std::out_of_range& e) {
67300       {
67301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67302       };
67303     } catch (std::exception& e) {
67304       {
67305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67306       };
67307     } catch (Dali::DaliException e) {
67308       {
67309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67310       };
67311     } catch (...) {
67312       {
67313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67314       };
67315     }
67316   }
67317
67318 }
67319
67320
67321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
67322   void * jresult ;
67323   Dali::BaseHandle arg1 ;
67324   Dali::BaseHandle *argp1 ;
67325   Dali::Toolkit::Alignment result;
67326
67327   argp1 = (Dali::BaseHandle *)jarg1;
67328   if (!argp1) {
67329     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67330     return 0;
67331   }
67332   arg1 = *argp1;
67333   {
67334     try {
67335       result = Dali::Toolkit::Alignment::DownCast(arg1);
67336     } catch (std::out_of_range& e) {
67337       {
67338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67339       };
67340     } catch (std::exception& e) {
67341       {
67342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67343       };
67344     } catch (Dali::DaliException e) {
67345       {
67346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67347       };
67348     } catch (...) {
67349       {
67350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67351       };
67352     }
67353   }
67354
67355   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
67356   return jresult;
67357 }
67358
67359
67360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
67361   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
67362   Dali::Toolkit::Alignment::Type arg2 ;
67363
67364   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67365   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
67366   {
67367     try {
67368       (arg1)->SetAlignmentType(arg2);
67369     } catch (std::out_of_range& e) {
67370       {
67371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67372       };
67373     } catch (std::exception& e) {
67374       {
67375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67376       };
67377     } catch (Dali::DaliException e) {
67378       {
67379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67380       };
67381     } catch (...) {
67382       {
67383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67384       };
67385     }
67386   }
67387
67388 }
67389
67390
67391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
67392   int jresult ;
67393   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
67394   Dali::Toolkit::Alignment::Type result;
67395
67396   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67397   {
67398     try {
67399       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
67400     } catch (std::out_of_range& e) {
67401       {
67402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67403       };
67404     } catch (std::exception& e) {
67405       {
67406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67407       };
67408     } catch (Dali::DaliException e) {
67409       {
67410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67411       };
67412     } catch (...) {
67413       {
67414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67415       };
67416     }
67417   }
67418
67419   jresult = (int)result;
67420   return jresult;
67421 }
67422
67423
67424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
67425   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
67426   Dali::Toolkit::Alignment::Scaling arg2 ;
67427
67428   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67429   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
67430   {
67431     try {
67432       (arg1)->SetScaling(arg2);
67433     } catch (std::out_of_range& e) {
67434       {
67435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67436       };
67437     } catch (std::exception& e) {
67438       {
67439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67440       };
67441     } catch (Dali::DaliException e) {
67442       {
67443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67444       };
67445     } catch (...) {
67446       {
67447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67448       };
67449     }
67450   }
67451
67452 }
67453
67454
67455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
67456   int jresult ;
67457   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
67458   Dali::Toolkit::Alignment::Scaling result;
67459
67460   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67461   {
67462     try {
67463       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
67464     } catch (std::out_of_range& e) {
67465       {
67466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67467       };
67468     } catch (std::exception& e) {
67469       {
67470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67471       };
67472     } catch (Dali::DaliException e) {
67473       {
67474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67475       };
67476     } catch (...) {
67477       {
67478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67479       };
67480     }
67481   }
67482
67483   jresult = (int)result;
67484   return jresult;
67485 }
67486
67487
67488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
67489   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
67490   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
67491
67492   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67493   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
67494   if (!arg2) {
67495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
67496     return ;
67497   }
67498   {
67499     try {
67500       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
67501     } catch (std::out_of_range& e) {
67502       {
67503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67504       };
67505     } catch (std::exception& e) {
67506       {
67507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67508       };
67509     } catch (Dali::DaliException e) {
67510       {
67511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67512       };
67513     } catch (...) {
67514       {
67515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67516       };
67517     }
67518   }
67519
67520 }
67521
67522
67523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
67524   void * jresult ;
67525   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
67526   Dali::Toolkit::Alignment::Padding *result = 0 ;
67527
67528   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67529   {
67530     try {
67531       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
67532     } catch (std::out_of_range& e) {
67533       {
67534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67535       };
67536     } catch (std::exception& e) {
67537       {
67538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67539       };
67540     } catch (Dali::DaliException e) {
67541       {
67542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67543       };
67544     } catch (...) {
67545       {
67546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67547       };
67548     }
67549   }
67550
67551   jresult = (void *)result;
67552   return jresult;
67553 }
67554
67555
67556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
67557   void * jresult ;
67558   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
67559   Dali::Toolkit::Alignment *arg2 = 0 ;
67560   Dali::Toolkit::Alignment *result = 0 ;
67561
67562   arg1 = (Dali::Toolkit::Alignment *)jarg1;
67563   arg2 = (Dali::Toolkit::Alignment *)jarg2;
67564   if (!arg2) {
67565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
67566     return 0;
67567   }
67568   {
67569     try {
67570       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
67571     } catch (std::out_of_range& e) {
67572       {
67573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67574       };
67575     } catch (std::exception& e) {
67576       {
67577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67578       };
67579     } catch (Dali::DaliException e) {
67580       {
67581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67582       };
67583     } catch (...) {
67584       {
67585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67586       };
67587     }
67588   }
67589
67590   jresult = (void *)result;
67591   return jresult;
67592 }
67593
67594
67595 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
67596   int jresult ;
67597   int result;
67598
67599   result = (int)Dali::Toolkit::Button::Property::DISABLED;
67600   jresult = (int)result;
67601   return jresult;
67602 }
67603
67604
67605 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
67606   int jresult ;
67607   int result;
67608
67609   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
67610   jresult = (int)result;
67611   return jresult;
67612 }
67613
67614
67615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
67616   int jresult ;
67617   int result;
67618
67619   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
67620   jresult = (int)result;
67621   return jresult;
67622 }
67623
67624
67625 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
67626   int jresult ;
67627   int result;
67628
67629   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
67630   jresult = (int)result;
67631   return jresult;
67632 }
67633
67634
67635 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
67636   int jresult ;
67637   int result;
67638
67639   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
67640   jresult = (int)result;
67641   return jresult;
67642 }
67643
67644
67645 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
67646   int jresult ;
67647   int result;
67648
67649   result = (int)Dali::Toolkit::Button::Property::SELECTED;
67650   jresult = (int)result;
67651   return jresult;
67652 }
67653
67654 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
67655   int jresult ;
67656   int result;
67657
67658   result = (int)Dali::Toolkit::Button::Property::LABEL;
67659   jresult = (int)result;
67660   return jresult;
67661 }
67662
67663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
67664   void * jresult ;
67665   Dali::Toolkit::Button::Property *result = 0 ;
67666
67667   {
67668     try {
67669       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
67670     } catch (std::out_of_range& e) {
67671       {
67672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67673       };
67674     } catch (std::exception& e) {
67675       {
67676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67677       };
67678     } catch (Dali::DaliException e) {
67679       {
67680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67681       };
67682     } catch (...) {
67683       {
67684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67685       };
67686     }
67687   }
67688
67689   jresult = (void *)result;
67690   return jresult;
67691 }
67692
67693
67694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
67695   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
67696
67697   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
67698   {
67699     try {
67700       delete arg1;
67701     } catch (std::out_of_range& e) {
67702       {
67703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67704       };
67705     } catch (std::exception& e) {
67706       {
67707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67708       };
67709     } catch (Dali::DaliException e) {
67710       {
67711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67712       };
67713     } catch (...) {
67714       {
67715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67716       };
67717     }
67718   }
67719
67720 }
67721
67722
67723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
67724   void * jresult ;
67725   Dali::Toolkit::Button *result = 0 ;
67726
67727   {
67728     try {
67729       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
67730     } catch (std::out_of_range& e) {
67731       {
67732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67733       };
67734     } catch (std::exception& e) {
67735       {
67736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67737       };
67738     } catch (Dali::DaliException e) {
67739       {
67740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67741       };
67742     } catch (...) {
67743       {
67744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67745       };
67746     }
67747   }
67748
67749   jresult = (void *)result;
67750   return jresult;
67751 }
67752
67753
67754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
67755   void * jresult ;
67756   Dali::Toolkit::Button *arg1 = 0 ;
67757   Dali::Toolkit::Button *result = 0 ;
67758
67759   arg1 = (Dali::Toolkit::Button *)jarg1;
67760   if (!arg1) {
67761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
67762     return 0;
67763   }
67764   {
67765     try {
67766       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
67767     } catch (std::out_of_range& e) {
67768       {
67769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67770       };
67771     } catch (std::exception& e) {
67772       {
67773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67774       };
67775     } catch (Dali::DaliException e) {
67776       {
67777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67778       };
67779     } catch (...) {
67780       {
67781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67782       };
67783     }
67784   }
67785
67786   jresult = (void *)result;
67787   return jresult;
67788 }
67789
67790
67791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
67792   void * jresult ;
67793   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67794   Dali::Toolkit::Button *arg2 = 0 ;
67795   Dali::Toolkit::Button *result = 0 ;
67796
67797   arg1 = (Dali::Toolkit::Button *)jarg1;
67798   arg2 = (Dali::Toolkit::Button *)jarg2;
67799   if (!arg2) {
67800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
67801     return 0;
67802   }
67803   {
67804     try {
67805       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
67806     } catch (std::out_of_range& e) {
67807       {
67808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67809       };
67810     } catch (std::exception& e) {
67811       {
67812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67813       };
67814     } catch (Dali::DaliException e) {
67815       {
67816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67817       };
67818     } catch (...) {
67819       {
67820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67821       };
67822     }
67823   }
67824
67825   jresult = (void *)result;
67826   return jresult;
67827 }
67828
67829
67830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
67831   void * jresult ;
67832   Dali::BaseHandle arg1 ;
67833   Dali::BaseHandle *argp1 ;
67834   Dali::Toolkit::Button result;
67835
67836   argp1 = (Dali::BaseHandle *)jarg1;
67837   if (!argp1) {
67838     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67839     return 0;
67840   }
67841   arg1 = *argp1;
67842   {
67843     try {
67844       result = Dali::Toolkit::Button::DownCast(arg1);
67845     } catch (std::out_of_range& e) {
67846       {
67847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67848       };
67849     } catch (std::exception& e) {
67850       {
67851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67852       };
67853     } catch (Dali::DaliException e) {
67854       {
67855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67856       };
67857     } catch (...) {
67858       {
67859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67860       };
67861     }
67862   }
67863
67864   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
67865   return jresult;
67866 }
67867
67868
67869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
67870   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67871
67872   arg1 = (Dali::Toolkit::Button *)jarg1;
67873   {
67874     try {
67875       delete arg1;
67876     } catch (std::out_of_range& e) {
67877       {
67878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67879       };
67880     } catch (std::exception& e) {
67881       {
67882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67883       };
67884     } catch (Dali::DaliException e) {
67885       {
67886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67887       };
67888     } catch (...) {
67889       {
67890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67891       };
67892     }
67893   }
67894
67895 }
67896
67897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
67898   void * jresult ;
67899   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67900   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
67901
67902   arg1 = (Dali::Toolkit::Button *)jarg1;
67903   {
67904     try {
67905       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
67906     } catch (std::out_of_range& e) {
67907       {
67908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67909       };
67910     } catch (std::exception& e) {
67911       {
67912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67913       };
67914     } catch (Dali::DaliException e) {
67915       {
67916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67917       };
67918     } catch (...) {
67919       {
67920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67921       };
67922     }
67923   }
67924
67925   jresult = (void *)result;
67926   return jresult;
67927 }
67928
67929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
67930   void * jresult ;
67931   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67932   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
67933
67934   arg1 = (Dali::Toolkit::Button *)jarg1;
67935   {
67936     try {
67937       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
67938     } catch (std::out_of_range& e) {
67939       {
67940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67941       };
67942     } catch (std::exception& e) {
67943       {
67944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67945       };
67946     } catch (Dali::DaliException e) {
67947       {
67948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67949       };
67950     } catch (...) {
67951       {
67952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67953       };
67954     }
67955   }
67956
67957   jresult = (void *)result;
67958   return jresult;
67959 }
67960
67961
67962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
67963   void * jresult ;
67964   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67965   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
67966
67967   arg1 = (Dali::Toolkit::Button *)jarg1;
67968   {
67969     try {
67970       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
67971     } catch (std::out_of_range& e) {
67972       {
67973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67974       };
67975     } catch (std::exception& e) {
67976       {
67977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67978       };
67979     } catch (Dali::DaliException e) {
67980       {
67981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67982       };
67983     } catch (...) {
67984       {
67985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67986       };
67987     }
67988   }
67989
67990   jresult = (void *)result;
67991   return jresult;
67992 }
67993
67994
67995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
67996   void * jresult ;
67997   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
67998   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
67999
68000   arg1 = (Dali::Toolkit::Button *)jarg1;
68001   {
68002     try {
68003       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
68004     } catch (std::out_of_range& e) {
68005       {
68006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68007       };
68008     } catch (std::exception& e) {
68009       {
68010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68011       };
68012     } catch (Dali::DaliException e) {
68013       {
68014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68015       };
68016     } catch (...) {
68017       {
68018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68019       };
68020     }
68021   }
68022
68023   jresult = (void *)result;
68024   return jresult;
68025 }
68026
68027
68028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
68029   void * jresult ;
68030   Dali::Toolkit::CheckBoxButton *result = 0 ;
68031
68032   {
68033     try {
68034       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
68035     } catch (std::out_of_range& e) {
68036       {
68037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68038       };
68039     } catch (std::exception& e) {
68040       {
68041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68042       };
68043     } catch (Dali::DaliException e) {
68044       {
68045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68046       };
68047     } catch (...) {
68048       {
68049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68050       };
68051     }
68052   }
68053
68054   jresult = (void *)result;
68055   return jresult;
68056 }
68057
68058
68059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
68060   void * jresult ;
68061   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
68062   Dali::Toolkit::CheckBoxButton *result = 0 ;
68063
68064   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
68065   if (!arg1) {
68066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
68067     return 0;
68068   }
68069   {
68070     try {
68071       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
68072     } catch (std::out_of_range& e) {
68073       {
68074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68075       };
68076     } catch (std::exception& e) {
68077       {
68078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68079       };
68080     } catch (Dali::DaliException e) {
68081       {
68082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68083       };
68084     } catch (...) {
68085       {
68086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68087       };
68088     }
68089   }
68090
68091   jresult = (void *)result;
68092   return jresult;
68093 }
68094
68095
68096 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
68097   void * jresult ;
68098   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
68099   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
68100   Dali::Toolkit::CheckBoxButton *result = 0 ;
68101
68102   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
68103   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
68104   if (!arg2) {
68105     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
68106     return 0;
68107   }
68108   {
68109     try {
68110       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
68111     } catch (std::out_of_range& e) {
68112       {
68113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68114       };
68115     } catch (std::exception& e) {
68116       {
68117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68118       };
68119     } catch (Dali::DaliException e) {
68120       {
68121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68122       };
68123     } catch (...) {
68124       {
68125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68126       };
68127     }
68128   }
68129
68130   jresult = (void *)result;
68131   return jresult;
68132 }
68133
68134
68135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
68136   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
68137
68138   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
68139   {
68140     try {
68141       delete arg1;
68142     } catch (std::out_of_range& e) {
68143       {
68144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68145       };
68146     } catch (std::exception& e) {
68147       {
68148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68149       };
68150     } catch (Dali::DaliException e) {
68151       {
68152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68153       };
68154     } catch (...) {
68155       {
68156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68157       };
68158     }
68159   }
68160
68161 }
68162
68163
68164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
68165   void * jresult ;
68166   Dali::Toolkit::CheckBoxButton result;
68167
68168   {
68169     try {
68170       result = Dali::Toolkit::CheckBoxButton::New();
68171     } catch (std::out_of_range& e) {
68172       {
68173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68174       };
68175     } catch (std::exception& e) {
68176       {
68177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68178       };
68179     } catch (Dali::DaliException e) {
68180       {
68181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68182       };
68183     } catch (...) {
68184       {
68185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68186       };
68187     }
68188   }
68189
68190   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
68191   return jresult;
68192 }
68193
68194
68195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
68196   void * jresult ;
68197   Dali::BaseHandle arg1 ;
68198   Dali::BaseHandle *argp1 ;
68199   Dali::Toolkit::CheckBoxButton result;
68200
68201   argp1 = (Dali::BaseHandle *)jarg1;
68202   if (!argp1) {
68203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68204     return 0;
68205   }
68206   arg1 = *argp1;
68207   {
68208     try {
68209       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
68210     } catch (std::out_of_range& e) {
68211       {
68212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68213       };
68214     } catch (std::exception& e) {
68215       {
68216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68217       };
68218     } catch (Dali::DaliException e) {
68219       {
68220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68221       };
68222     } catch (...) {
68223       {
68224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68225       };
68226     }
68227   }
68228
68229   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
68230   return jresult;
68231 }
68232
68233
68234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_UNSELECTED_ICON_get() {
68235   int jresult ;
68236   int result;
68237
68238   result = (int)Dali::Toolkit::PushButton::Property::UNSELECTED_ICON;
68239   jresult = (int)result;
68240   return jresult;
68241 }
68242
68243
68244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_SELECTED_ICON_get() {
68245   int jresult ;
68246   int result;
68247
68248   result = (int)Dali::Toolkit::PushButton::Property::SELECTED_ICON;
68249   jresult = (int)result;
68250   return jresult;
68251 }
68252
68253
68254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_ALIGNMENT_get() {
68255   int jresult ;
68256   int result;
68257
68258   result = (int)Dali::Toolkit::PushButton::Property::ICON_ALIGNMENT;
68259   jresult = (int)result;
68260   return jresult;
68261 }
68262
68263
68264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
68265   int jresult ;
68266   int result;
68267
68268   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
68269   jresult = (int)result;
68270   return jresult;
68271 }
68272
68273
68274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
68275   int jresult ;
68276   int result;
68277
68278   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
68279   jresult = (int)result;
68280   return jresult;
68281 }
68282
68283
68284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
68285   void * jresult ;
68286   Dali::Toolkit::PushButton::Property *result = 0 ;
68287
68288   {
68289     try {
68290       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
68291     } catch (std::out_of_range& e) {
68292       {
68293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68294       };
68295     } catch (std::exception& e) {
68296       {
68297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68298       };
68299     } catch (Dali::DaliException e) {
68300       {
68301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68302       };
68303     } catch (...) {
68304       {
68305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68306       };
68307     }
68308   }
68309
68310   jresult = (void *)result;
68311   return jresult;
68312 }
68313
68314
68315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
68316   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
68317
68318   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
68319   {
68320     try {
68321       delete arg1;
68322     } catch (std::out_of_range& e) {
68323       {
68324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68325       };
68326     } catch (std::exception& e) {
68327       {
68328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68329       };
68330     } catch (Dali::DaliException e) {
68331       {
68332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68333       };
68334     } catch (...) {
68335       {
68336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68337       };
68338     }
68339   }
68340
68341 }
68342
68343
68344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
68345   void * jresult ;
68346   Dali::Toolkit::PushButton *result = 0 ;
68347
68348   {
68349     try {
68350       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
68351     } catch (std::out_of_range& e) {
68352       {
68353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68354       };
68355     } catch (std::exception& e) {
68356       {
68357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68358       };
68359     } catch (Dali::DaliException e) {
68360       {
68361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68362       };
68363     } catch (...) {
68364       {
68365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68366       };
68367     }
68368   }
68369
68370   jresult = (void *)result;
68371   return jresult;
68372 }
68373
68374
68375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
68376   void * jresult ;
68377   Dali::Toolkit::PushButton *arg1 = 0 ;
68378   Dali::Toolkit::PushButton *result = 0 ;
68379
68380   arg1 = (Dali::Toolkit::PushButton *)jarg1;
68381   if (!arg1) {
68382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
68383     return 0;
68384   }
68385   {
68386     try {
68387       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
68388     } catch (std::out_of_range& e) {
68389       {
68390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68391       };
68392     } catch (std::exception& e) {
68393       {
68394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68395       };
68396     } catch (Dali::DaliException e) {
68397       {
68398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68399       };
68400     } catch (...) {
68401       {
68402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68403       };
68404     }
68405   }
68406
68407   jresult = (void *)result;
68408   return jresult;
68409 }
68410
68411
68412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
68413   void * jresult ;
68414   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
68415   Dali::Toolkit::PushButton *arg2 = 0 ;
68416   Dali::Toolkit::PushButton *result = 0 ;
68417
68418   arg1 = (Dali::Toolkit::PushButton *)jarg1;
68419   arg2 = (Dali::Toolkit::PushButton *)jarg2;
68420   if (!arg2) {
68421     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
68422     return 0;
68423   }
68424   {
68425     try {
68426       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
68427     } catch (std::out_of_range& e) {
68428       {
68429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68430       };
68431     } catch (std::exception& e) {
68432       {
68433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68434       };
68435     } catch (Dali::DaliException e) {
68436       {
68437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68438       };
68439     } catch (...) {
68440       {
68441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68442       };
68443     }
68444   }
68445
68446   jresult = (void *)result;
68447   return jresult;
68448 }
68449
68450
68451 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
68452   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
68453
68454   arg1 = (Dali::Toolkit::PushButton *)jarg1;
68455   {
68456     try {
68457       delete arg1;
68458     } catch (std::out_of_range& e) {
68459       {
68460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68461       };
68462     } catch (std::exception& e) {
68463       {
68464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68465       };
68466     } catch (Dali::DaliException e) {
68467       {
68468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68469       };
68470     } catch (...) {
68471       {
68472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68473       };
68474     }
68475   }
68476
68477 }
68478
68479
68480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
68481   void * jresult ;
68482   Dali::Toolkit::PushButton result;
68483
68484   {
68485     try {
68486       result = Dali::Toolkit::PushButton::New();
68487     } catch (std::out_of_range& e) {
68488       {
68489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68490       };
68491     } catch (std::exception& e) {
68492       {
68493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68494       };
68495     } catch (Dali::DaliException e) {
68496       {
68497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68498       };
68499     } catch (...) {
68500       {
68501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68502       };
68503     }
68504   }
68505
68506   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
68507   return jresult;
68508 }
68509
68510
68511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
68512   void * jresult ;
68513   Dali::BaseHandle arg1 ;
68514   Dali::BaseHandle *argp1 ;
68515   Dali::Toolkit::PushButton result;
68516
68517   argp1 = (Dali::BaseHandle *)jarg1;
68518   if (!argp1) {
68519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68520     return 0;
68521   }
68522   arg1 = *argp1;
68523   {
68524     try {
68525       result = Dali::Toolkit::PushButton::DownCast(arg1);
68526     } catch (std::out_of_range& e) {
68527       {
68528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68529       };
68530     } catch (std::exception& e) {
68531       {
68532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68533       };
68534     } catch (Dali::DaliException e) {
68535       {
68536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68537       };
68538     } catch (...) {
68539       {
68540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68541       };
68542     }
68543   }
68544
68545   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
68546   return jresult;
68547 }
68548
68549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
68550   void * jresult ;
68551   Dali::Toolkit::RadioButton *result = 0 ;
68552
68553   {
68554     try {
68555       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
68556     } catch (std::out_of_range& e) {
68557       {
68558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68559       };
68560     } catch (std::exception& e) {
68561       {
68562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68563       };
68564     } catch (Dali::DaliException e) {
68565       {
68566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68567       };
68568     } catch (...) {
68569       {
68570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68571       };
68572     }
68573   }
68574
68575   jresult = (void *)result;
68576   return jresult;
68577 }
68578
68579
68580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
68581   void * jresult ;
68582   Dali::Toolkit::RadioButton *arg1 = 0 ;
68583   Dali::Toolkit::RadioButton *result = 0 ;
68584
68585   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
68586   if (!arg1) {
68587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
68588     return 0;
68589   }
68590   {
68591     try {
68592       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
68593     } catch (std::out_of_range& e) {
68594       {
68595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68596       };
68597     } catch (std::exception& e) {
68598       {
68599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68600       };
68601     } catch (Dali::DaliException e) {
68602       {
68603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68604       };
68605     } catch (...) {
68606       {
68607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68608       };
68609     }
68610   }
68611
68612   jresult = (void *)result;
68613   return jresult;
68614 }
68615
68616
68617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
68618   void * jresult ;
68619   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
68620   Dali::Toolkit::RadioButton *arg2 = 0 ;
68621   Dali::Toolkit::RadioButton *result = 0 ;
68622
68623   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
68624   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
68625   if (!arg2) {
68626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
68627     return 0;
68628   }
68629   {
68630     try {
68631       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
68632     } catch (std::out_of_range& e) {
68633       {
68634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68635       };
68636     } catch (std::exception& e) {
68637       {
68638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68639       };
68640     } catch (Dali::DaliException e) {
68641       {
68642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68643       };
68644     } catch (...) {
68645       {
68646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68647       };
68648     }
68649   }
68650
68651   jresult = (void *)result;
68652   return jresult;
68653 }
68654
68655
68656 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
68657   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
68658
68659   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
68660   {
68661     try {
68662       delete arg1;
68663     } catch (std::out_of_range& e) {
68664       {
68665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68666       };
68667     } catch (std::exception& e) {
68668       {
68669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68670       };
68671     } catch (Dali::DaliException e) {
68672       {
68673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68674       };
68675     } catch (...) {
68676       {
68677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68678       };
68679     }
68680   }
68681
68682 }
68683
68684
68685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
68686   void * jresult ;
68687   Dali::Toolkit::RadioButton result;
68688
68689   {
68690     try {
68691       result = Dali::Toolkit::RadioButton::New();
68692     } catch (std::out_of_range& e) {
68693       {
68694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68695       };
68696     } catch (std::exception& e) {
68697       {
68698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68699       };
68700     } catch (Dali::DaliException e) {
68701       {
68702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68703       };
68704     } catch (...) {
68705       {
68706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68707       };
68708     }
68709   }
68710
68711   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
68712   return jresult;
68713 }
68714
68715
68716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
68717   void * jresult ;
68718   std::string *arg1 = 0 ;
68719   Dali::Toolkit::RadioButton result;
68720
68721   if (!jarg1) {
68722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
68723     return 0;
68724   }
68725   std::string arg1_str(jarg1);
68726   arg1 = &arg1_str;
68727   {
68728     try {
68729       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
68730     } catch (std::out_of_range& e) {
68731       {
68732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68733       };
68734     } catch (std::exception& e) {
68735       {
68736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68737       };
68738     } catch (Dali::DaliException e) {
68739       {
68740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68741       };
68742     } catch (...) {
68743       {
68744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68745       };
68746     }
68747   }
68748
68749   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
68750
68751   //argout typemap for const std::string&
68752
68753   return jresult;
68754 }
68755
68756
68757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
68758   void * jresult ;
68759   Dali::BaseHandle arg1 ;
68760   Dali::BaseHandle *argp1 ;
68761   Dali::Toolkit::RadioButton result;
68762
68763   argp1 = (Dali::BaseHandle *)jarg1;
68764   if (!argp1) {
68765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68766     return 0;
68767   }
68768   arg1 = *argp1;
68769   {
68770     try {
68771       result = Dali::Toolkit::RadioButton::DownCast(arg1);
68772     } catch (std::out_of_range& e) {
68773       {
68774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68775       };
68776     } catch (std::exception& e) {
68777       {
68778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68779       };
68780     } catch (Dali::DaliException e) {
68781       {
68782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68783       };
68784     } catch (...) {
68785       {
68786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68787       };
68788     }
68789   }
68790
68791   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
68792   return jresult;
68793 }
68794
68795
68796 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
68797   int jresult ;
68798   int result;
68799
68800   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
68801   jresult = (int)result;
68802   return jresult;
68803 }
68804
68805
68806 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
68807   int jresult ;
68808   int result;
68809
68810   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
68811   jresult = (int)result;
68812   return jresult;
68813 }
68814
68815
68816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
68817   int jresult ;
68818   int result;
68819
68820   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
68821   jresult = (int)result;
68822   return jresult;
68823 }
68824
68825
68826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
68827   int jresult ;
68828   int result;
68829
68830   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
68831   jresult = (int)result;
68832   return jresult;
68833 }
68834
68835
68836 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
68837   int jresult ;
68838   int result;
68839
68840   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
68841   jresult = (int)result;
68842   return jresult;
68843 }
68844
68845
68846 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
68847   int jresult ;
68848   int result;
68849
68850   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
68851   jresult = (int)result;
68852   return jresult;
68853 }
68854
68855
68856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
68857   void * jresult ;
68858   Dali::Toolkit::FlexContainer::Property *result = 0 ;
68859
68860   {
68861     try {
68862       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
68863     } catch (std::out_of_range& e) {
68864       {
68865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68866       };
68867     } catch (std::exception& e) {
68868       {
68869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68870       };
68871     } catch (Dali::DaliException e) {
68872       {
68873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68874       };
68875     } catch (...) {
68876       {
68877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68878       };
68879     }
68880   }
68881
68882   jresult = (void *)result;
68883   return jresult;
68884 }
68885
68886
68887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
68888   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
68889
68890   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
68891   {
68892     try {
68893       delete arg1;
68894     } catch (std::out_of_range& e) {
68895       {
68896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68897       };
68898     } catch (std::exception& e) {
68899       {
68900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68901       };
68902     } catch (Dali::DaliException e) {
68903       {
68904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68905       };
68906     } catch (...) {
68907       {
68908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68909       };
68910     }
68911   }
68912
68913 }
68914
68915
68916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
68917   int jresult ;
68918   int result;
68919
68920   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
68921   jresult = (int)result;
68922   return jresult;
68923 }
68924
68925
68926 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
68927   int jresult ;
68928   int result;
68929
68930   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
68931   jresult = (int)result;
68932   return jresult;
68933 }
68934
68935
68936 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
68937   int jresult ;
68938   int result;
68939
68940   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
68941   jresult = (int)result;
68942   return jresult;
68943 }
68944
68945
68946 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
68947   void * jresult ;
68948   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
68949
68950   {
68951     try {
68952       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
68953     } catch (std::out_of_range& e) {
68954       {
68955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68956       };
68957     } catch (std::exception& e) {
68958       {
68959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68960       };
68961     } catch (Dali::DaliException e) {
68962       {
68963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68964       };
68965     } catch (...) {
68966       {
68967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68968       };
68969     }
68970   }
68971
68972   jresult = (void *)result;
68973   return jresult;
68974 }
68975
68976
68977 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
68978   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
68979
68980   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
68981   {
68982     try {
68983       delete arg1;
68984     } catch (std::out_of_range& e) {
68985       {
68986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68987       };
68988     } catch (std::exception& e) {
68989       {
68990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68991       };
68992     } catch (Dali::DaliException e) {
68993       {
68994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68995       };
68996     } catch (...) {
68997       {
68998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68999       };
69000     }
69001   }
69002
69003 }
69004
69005
69006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
69007   void * jresult ;
69008   Dali::Toolkit::FlexContainer *result = 0 ;
69009
69010   {
69011     try {
69012       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
69013     } catch (std::out_of_range& e) {
69014       {
69015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69016       };
69017     } catch (std::exception& e) {
69018       {
69019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69020       };
69021     } catch (Dali::DaliException e) {
69022       {
69023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69024       };
69025     } catch (...) {
69026       {
69027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69028       };
69029     }
69030   }
69031
69032   jresult = (void *)result;
69033   return jresult;
69034 }
69035
69036
69037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
69038   void * jresult ;
69039   Dali::Toolkit::FlexContainer *arg1 = 0 ;
69040   Dali::Toolkit::FlexContainer *result = 0 ;
69041
69042   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
69043   if (!arg1) {
69044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
69045     return 0;
69046   }
69047   {
69048     try {
69049       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
69050     } catch (std::out_of_range& e) {
69051       {
69052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69053       };
69054     } catch (std::exception& e) {
69055       {
69056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69057       };
69058     } catch (Dali::DaliException e) {
69059       {
69060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69061       };
69062     } catch (...) {
69063       {
69064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69065       };
69066     }
69067   }
69068
69069   jresult = (void *)result;
69070   return jresult;
69071 }
69072
69073
69074 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
69075   void * jresult ;
69076   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
69077   Dali::Toolkit::FlexContainer *arg2 = 0 ;
69078   Dali::Toolkit::FlexContainer *result = 0 ;
69079
69080   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
69081   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
69082   if (!arg2) {
69083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
69084     return 0;
69085   }
69086   {
69087     try {
69088       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
69089     } catch (std::out_of_range& e) {
69090       {
69091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69092       };
69093     } catch (std::exception& e) {
69094       {
69095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69096       };
69097     } catch (Dali::DaliException e) {
69098       {
69099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69100       };
69101     } catch (...) {
69102       {
69103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69104       };
69105     }
69106   }
69107
69108   jresult = (void *)result;
69109   return jresult;
69110 }
69111
69112
69113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
69114   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
69115
69116   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
69117   {
69118     try {
69119       delete arg1;
69120     } catch (std::out_of_range& e) {
69121       {
69122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69123       };
69124     } catch (std::exception& e) {
69125       {
69126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69127       };
69128     } catch (Dali::DaliException e) {
69129       {
69130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69131       };
69132     } catch (...) {
69133       {
69134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69135       };
69136     }
69137   }
69138
69139 }
69140
69141
69142 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
69143   void * jresult ;
69144   Dali::Toolkit::FlexContainer result;
69145
69146   {
69147     try {
69148       result = Dali::Toolkit::FlexContainer::New();
69149     } catch (std::out_of_range& e) {
69150       {
69151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69152       };
69153     } catch (std::exception& e) {
69154       {
69155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69156       };
69157     } catch (Dali::DaliException e) {
69158       {
69159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69160       };
69161     } catch (...) {
69162       {
69163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69164       };
69165     }
69166   }
69167
69168   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
69169   return jresult;
69170 }
69171
69172
69173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
69174   void * jresult ;
69175   Dali::BaseHandle arg1 ;
69176   Dali::BaseHandle *argp1 ;
69177   Dali::Toolkit::FlexContainer result;
69178
69179   argp1 = (Dali::BaseHandle *)jarg1;
69180   if (!argp1) {
69181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69182     return 0;
69183   }
69184   arg1 = *argp1;
69185   {
69186     try {
69187       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
69188     } catch (std::out_of_range& e) {
69189       {
69190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69191       };
69192     } catch (std::exception& e) {
69193       {
69194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69195       };
69196     } catch (Dali::DaliException e) {
69197       {
69198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69199       };
69200     } catch (...) {
69201       {
69202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69203       };
69204     }
69205   }
69206
69207   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
69208   return jresult;
69209 }
69210
69211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
69212   int jresult ;
69213   int result;
69214
69215   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
69216   jresult = (int)result;
69217   return jresult;
69218 }
69219
69220
69221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
69222   int jresult ;
69223   int result;
69224
69225   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
69226   jresult = (int)result;
69227   return jresult;
69228 }
69229
69230
69231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
69232   int jresult ;
69233   int result;
69234
69235   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
69236   jresult = (int)result;
69237   return jresult;
69238 }
69239
69240
69241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
69242   void * jresult ;
69243   Dali::Toolkit::ImageView::Property *result = 0 ;
69244
69245   {
69246     try {
69247       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
69248     } catch (std::out_of_range& e) {
69249       {
69250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69251       };
69252     } catch (std::exception& e) {
69253       {
69254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69255       };
69256     } catch (Dali::DaliException e) {
69257       {
69258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69259       };
69260     } catch (...) {
69261       {
69262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69263       };
69264     }
69265   }
69266
69267   jresult = (void *)result;
69268   return jresult;
69269 }
69270
69271
69272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
69273   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
69274
69275   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
69276   {
69277     try {
69278       delete arg1;
69279     } catch (std::out_of_range& e) {
69280       {
69281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69282       };
69283     } catch (std::exception& e) {
69284       {
69285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69286       };
69287     } catch (Dali::DaliException e) {
69288       {
69289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69290       };
69291     } catch (...) {
69292       {
69293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69294       };
69295     }
69296   }
69297
69298 }
69299
69300
69301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
69302   void * jresult ;
69303   Dali::Toolkit::ImageView *result = 0 ;
69304
69305   {
69306     try {
69307       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
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 (Dali::DaliException e) {
69317       {
69318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69319       };
69320     } catch (...) {
69321       {
69322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69323       };
69324     }
69325   }
69326
69327   jresult = (void *)result;
69328   return jresult;
69329 }
69330
69331
69332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
69333   void * jresult ;
69334   Dali::Toolkit::ImageView result;
69335
69336   {
69337     try {
69338       result = Dali::Toolkit::ImageView::New();
69339     } catch (std::out_of_range& e) {
69340       {
69341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69342       };
69343     } catch (std::exception& e) {
69344       {
69345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69346       };
69347     } catch (Dali::DaliException e) {
69348       {
69349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69350       };
69351     } catch (...) {
69352       {
69353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69354       };
69355     }
69356   }
69357
69358   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
69359   return jresult;
69360 }
69361
69362
69363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_1(void * jarg1) {
69364   void * jresult ;
69365   Dali::Image arg1 ;
69366   Dali::Image *argp1 ;
69367   Dali::Toolkit::ImageView result;
69368
69369   argp1 = (Dali::Image *)jarg1;
69370   if (!argp1) {
69371     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69372     return 0;
69373   }
69374   arg1 = *argp1;
69375   {
69376     try {
69377       result = Dali::Toolkit::ImageView::New(arg1);
69378     } catch (std::out_of_range& e) {
69379       {
69380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69381       };
69382     } catch (std::exception& e) {
69383       {
69384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69385       };
69386     } catch (Dali::DaliException e) {
69387       {
69388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69389       };
69390     } catch (...) {
69391       {
69392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69393       };
69394     }
69395   }
69396
69397   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
69398   return jresult;
69399 }
69400
69401
69402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
69403   void * jresult ;
69404   std::string *arg1 = 0 ;
69405   Dali::Toolkit::ImageView result;
69406
69407   if (!jarg1) {
69408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69409     return 0;
69410   }
69411   std::string arg1_str(jarg1);
69412   arg1 = &arg1_str;
69413   {
69414     try {
69415       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
69416     } catch (std::out_of_range& e) {
69417       {
69418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69419       };
69420     } catch (std::exception& e) {
69421       {
69422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69423       };
69424     } catch (Dali::DaliException e) {
69425       {
69426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69427       };
69428     } catch (...) {
69429       {
69430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69431       };
69432     }
69433   }
69434
69435   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
69436
69437   //argout typemap for const std::string&
69438
69439   return jresult;
69440 }
69441
69442
69443 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
69444   void * jresult ;
69445   std::string *arg1 = 0 ;
69446   Dali::ImageDimensions arg2 ;
69447   Dali::ImageDimensions *argp2 ;
69448   Dali::Toolkit::ImageView result;
69449
69450   if (!jarg1) {
69451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69452     return 0;
69453   }
69454   std::string arg1_str(jarg1);
69455   arg1 = &arg1_str;
69456   argp2 = (Dali::ImageDimensions *)jarg2;
69457   if (!argp2) {
69458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
69459     return 0;
69460   }
69461   arg2 = *argp2;
69462   {
69463     try {
69464       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
69465     } catch (std::out_of_range& e) {
69466       {
69467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69468       };
69469     } catch (std::exception& e) {
69470       {
69471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69472       };
69473     } catch (Dali::DaliException e) {
69474       {
69475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69476       };
69477     } catch (...) {
69478       {
69479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69480       };
69481     }
69482   }
69483
69484   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
69485
69486   //argout typemap for const std::string&
69487
69488   return jresult;
69489 }
69490
69491
69492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
69493   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
69494
69495   arg1 = (Dali::Toolkit::ImageView *)jarg1;
69496   {
69497     try {
69498       delete arg1;
69499     } catch (std::out_of_range& e) {
69500       {
69501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69502       };
69503     } catch (std::exception& e) {
69504       {
69505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69506       };
69507     } catch (Dali::DaliException e) {
69508       {
69509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69510       };
69511     } catch (...) {
69512       {
69513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69514       };
69515     }
69516   }
69517
69518 }
69519
69520
69521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
69522   void * jresult ;
69523   Dali::Toolkit::ImageView *arg1 = 0 ;
69524   Dali::Toolkit::ImageView *result = 0 ;
69525
69526   arg1 = (Dali::Toolkit::ImageView *)jarg1;
69527   if (!arg1) {
69528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
69529     return 0;
69530   }
69531   {
69532     try {
69533       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
69534     } catch (std::out_of_range& e) {
69535       {
69536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69537       };
69538     } catch (std::exception& e) {
69539       {
69540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69541       };
69542     } catch (Dali::DaliException e) {
69543       {
69544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69545       };
69546     } catch (...) {
69547       {
69548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69549       };
69550     }
69551   }
69552
69553   jresult = (void *)result;
69554   return jresult;
69555 }
69556
69557
69558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
69559   void * jresult ;
69560   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
69561   Dali::Toolkit::ImageView *arg2 = 0 ;
69562   Dali::Toolkit::ImageView *result = 0 ;
69563
69564   arg1 = (Dali::Toolkit::ImageView *)jarg1;
69565   arg2 = (Dali::Toolkit::ImageView *)jarg2;
69566   if (!arg2) {
69567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
69568     return 0;
69569   }
69570   {
69571     try {
69572       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
69573     } catch (std::out_of_range& e) {
69574       {
69575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69576       };
69577     } catch (std::exception& e) {
69578       {
69579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69580       };
69581     } catch (Dali::DaliException e) {
69582       {
69583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69584       };
69585     } catch (...) {
69586       {
69587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69588       };
69589     }
69590   }
69591
69592   jresult = (void *)result;
69593   return jresult;
69594 }
69595
69596
69597 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
69598   void * jresult ;
69599   Dali::BaseHandle arg1 ;
69600   Dali::BaseHandle *argp1 ;
69601   Dali::Toolkit::ImageView result;
69602
69603   argp1 = (Dali::BaseHandle *)jarg1;
69604   if (!argp1) {
69605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69606     return 0;
69607   }
69608   arg1 = *argp1;
69609   {
69610     try {
69611       result = Dali::Toolkit::ImageView::DownCast(arg1);
69612     } catch (std::out_of_range& e) {
69613       {
69614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69615       };
69616     } catch (std::exception& e) {
69617       {
69618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69619       };
69620     } catch (Dali::DaliException e) {
69621       {
69622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69623       };
69624     } catch (...) {
69625       {
69626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69627       };
69628     }
69629   }
69630
69631   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
69632   return jresult;
69633 }
69634
69635
69636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_0(void * jarg1, void * jarg2) {
69637   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
69638   Dali::Image arg2 ;
69639   Dali::Image *argp2 ;
69640
69641   arg1 = (Dali::Toolkit::ImageView *)jarg1;
69642   argp2 = (Dali::Image *)jarg2;
69643   if (!argp2) {
69644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Image", 0);
69645     return ;
69646   }
69647   arg2 = *argp2;
69648   {
69649     try {
69650       (arg1)->SetImage(arg2);
69651     } catch (std::out_of_range& e) {
69652       {
69653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69654       };
69655     } catch (std::exception& e) {
69656       {
69657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69658       };
69659     } catch (Dali::DaliException e) {
69660       {
69661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69662       };
69663     } catch (...) {
69664       {
69665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69666       };
69667     }
69668   }
69669
69670 }
69671
69672
69673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
69674   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
69675   std::string *arg2 = 0 ;
69676
69677   arg1 = (Dali::Toolkit::ImageView *)jarg1;
69678   if (!jarg2) {
69679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69680     return ;
69681   }
69682   std::string arg2_str(jarg2);
69683   arg2 = &arg2_str;
69684   {
69685     try {
69686       (arg1)->SetImage((std::string const &)*arg2);
69687     } catch (std::out_of_range& e) {
69688       {
69689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69690       };
69691     } catch (std::exception& e) {
69692       {
69693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69694       };
69695     } catch (Dali::DaliException e) {
69696       {
69697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69698       };
69699     } catch (...) {
69700       {
69701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69702       };
69703     }
69704   }
69705
69706
69707   //argout typemap for const std::string&
69708
69709 }
69710
69711
69712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
69713   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
69714   std::string *arg2 = 0 ;
69715   Dali::ImageDimensions arg3 ;
69716   Dali::ImageDimensions *argp3 ;
69717
69718   arg1 = (Dali::Toolkit::ImageView *)jarg1;
69719   if (!jarg2) {
69720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69721     return ;
69722   }
69723   std::string arg2_str(jarg2);
69724   arg2 = &arg2_str;
69725   argp3 = (Dali::ImageDimensions *)jarg3;
69726   if (!argp3) {
69727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
69728     return ;
69729   }
69730   arg3 = *argp3;
69731   {
69732     try {
69733       (arg1)->SetImage((std::string const &)*arg2,arg3);
69734     } catch (std::out_of_range& e) {
69735       {
69736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69737       };
69738     } catch (std::exception& e) {
69739       {
69740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69741       };
69742     } catch (Dali::DaliException e) {
69743       {
69744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69745       };
69746     } catch (...) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69749       };
69750     }
69751   }
69752
69753
69754   //argout typemap for const std::string&
69755
69756 }
69757
69758 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_GetImage(void * jarg1) {
69759   void * jresult ;
69760   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
69761   Dali::Image result;
69762
69763   arg1 = (Dali::Toolkit::ImageView *)jarg1;
69764   {
69765     try {
69766       result = ((Dali::Toolkit::ImageView const *)arg1)->GetImage();
69767     } catch (std::out_of_range& e) {
69768       {
69769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69770       };
69771     } catch (std::exception& e) {
69772       {
69773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69774       };
69775     } catch (Dali::DaliException e) {
69776       {
69777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69778       };
69779     } catch (...) {
69780       {
69781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69782       };
69783     }
69784   }
69785
69786   jresult = new Dali::Image((const Dali::Image &)result);
69787   return jresult;
69788 }
69789
69790
69791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
69792   int jresult ;
69793   int result;
69794
69795   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
69796   jresult = (int)result;
69797   return jresult;
69798 }
69799
69800
69801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
69802   int jresult ;
69803   int result;
69804
69805   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
69806   jresult = (int)result;
69807   return jresult;
69808 }
69809
69810
69811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
69812   int jresult ;
69813   int result;
69814
69815   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
69816   jresult = (int)result;
69817   return jresult;
69818 }
69819
69820
69821 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
69822   int jresult ;
69823   int result;
69824
69825   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
69826   jresult = (int)result;
69827   return jresult;
69828 }
69829
69830
69831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
69832   int jresult ;
69833   int result;
69834
69835   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
69836   jresult = (int)result;
69837   return jresult;
69838 }
69839
69840
69841 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
69842   int jresult ;
69843   int result;
69844
69845   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
69846   jresult = (int)result;
69847   return jresult;
69848 }
69849
69850
69851 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
69852   int jresult ;
69853   int result;
69854
69855   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
69856   jresult = (int)result;
69857   return jresult;
69858 }
69859
69860
69861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
69862   int jresult ;
69863   int result;
69864
69865   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
69866   jresult = (int)result;
69867   return jresult;
69868 }
69869
69870
69871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
69872   void * jresult ;
69873   Dali::Toolkit::Model3dView::Property *result = 0 ;
69874
69875   {
69876     try {
69877       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
69878     } catch (std::out_of_range& e) {
69879       {
69880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69881       };
69882     } catch (std::exception& e) {
69883       {
69884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69885       };
69886     } catch (Dali::DaliException e) {
69887       {
69888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69889       };
69890     } catch (...) {
69891       {
69892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69893       };
69894     }
69895   }
69896
69897   jresult = (void *)result;
69898   return jresult;
69899 }
69900
69901
69902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
69903   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
69904
69905   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
69906   {
69907     try {
69908       delete arg1;
69909     } catch (std::out_of_range& e) {
69910       {
69911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69912       };
69913     } catch (std::exception& e) {
69914       {
69915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69916       };
69917     } catch (Dali::DaliException e) {
69918       {
69919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69920       };
69921     } catch (...) {
69922       {
69923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69924       };
69925     }
69926   }
69927
69928 }
69929
69930
69931 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
69932   void * jresult ;
69933   Dali::Toolkit::Model3dView result;
69934
69935   {
69936     try {
69937       result = Dali::Toolkit::Model3dView::New();
69938     } catch (std::out_of_range& e) {
69939       {
69940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69941       };
69942     } catch (std::exception& e) {
69943       {
69944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (Dali::DaliException e) {
69947       {
69948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69949       };
69950     } catch (...) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69953       };
69954     }
69955   }
69956
69957   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
69958   return jresult;
69959 }
69960
69961
69962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
69963   void * jresult ;
69964   std::string *arg1 = 0 ;
69965   std::string *arg2 = 0 ;
69966   std::string *arg3 = 0 ;
69967   Dali::Toolkit::Model3dView result;
69968
69969   if (!jarg1) {
69970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69971     return 0;
69972   }
69973   std::string arg1_str(jarg1);
69974   arg1 = &arg1_str;
69975   if (!jarg2) {
69976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69977     return 0;
69978   }
69979   std::string arg2_str(jarg2);
69980   arg2 = &arg2_str;
69981   if (!jarg3) {
69982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
69983     return 0;
69984   }
69985   std::string arg3_str(jarg3);
69986   arg3 = &arg3_str;
69987   {
69988     try {
69989       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
69990     } catch (std::out_of_range& e) {
69991       {
69992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69993       };
69994     } catch (std::exception& e) {
69995       {
69996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69997       };
69998     } catch (Dali::DaliException e) {
69999       {
70000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70001       };
70002     } catch (...) {
70003       {
70004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70005       };
70006     }
70007   }
70008
70009   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
70010
70011   //argout typemap for const std::string&
70012
70013
70014   //argout typemap for const std::string&
70015
70016
70017   //argout typemap for const std::string&
70018
70019   return jresult;
70020 }
70021
70022
70023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
70024   void * jresult ;
70025   Dali::Toolkit::Model3dView *result = 0 ;
70026
70027   {
70028     try {
70029       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
70030     } catch (std::out_of_range& e) {
70031       {
70032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70033       };
70034     } catch (std::exception& e) {
70035       {
70036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70037       };
70038     } catch (Dali::DaliException e) {
70039       {
70040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70041       };
70042     } catch (...) {
70043       {
70044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70045       };
70046     }
70047   }
70048
70049   jresult = (void *)result;
70050   return jresult;
70051 }
70052
70053
70054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
70055   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
70056
70057   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
70058   {
70059     try {
70060       delete arg1;
70061     } catch (std::out_of_range& e) {
70062       {
70063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70064       };
70065     } catch (std::exception& e) {
70066       {
70067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70068       };
70069     } catch (Dali::DaliException e) {
70070       {
70071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70072       };
70073     } catch (...) {
70074       {
70075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70076       };
70077     }
70078   }
70079
70080 }
70081
70082
70083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
70084   void * jresult ;
70085   Dali::Toolkit::Model3dView *arg1 = 0 ;
70086   Dali::Toolkit::Model3dView *result = 0 ;
70087
70088   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
70089   if (!arg1) {
70090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
70091     return 0;
70092   }
70093   {
70094     try {
70095       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
70096     } catch (std::out_of_range& e) {
70097       {
70098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70099       };
70100     } catch (std::exception& e) {
70101       {
70102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70103       };
70104     } catch (Dali::DaliException e) {
70105       {
70106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70107       };
70108     } catch (...) {
70109       {
70110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70111       };
70112     }
70113   }
70114
70115   jresult = (void *)result;
70116   return jresult;
70117 }
70118
70119
70120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
70121   void * jresult ;
70122   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
70123   Dali::Toolkit::Model3dView *arg2 = 0 ;
70124   Dali::Toolkit::Model3dView *result = 0 ;
70125
70126   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
70127   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
70128   if (!arg2) {
70129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
70130     return 0;
70131   }
70132   {
70133     try {
70134       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
70135     } catch (std::out_of_range& e) {
70136       {
70137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70138       };
70139     } catch (std::exception& e) {
70140       {
70141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70142       };
70143     } catch (Dali::DaliException e) {
70144       {
70145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70146       };
70147     } catch (...) {
70148       {
70149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70150       };
70151     }
70152   }
70153
70154   jresult = (void *)result;
70155   return jresult;
70156 }
70157
70158
70159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
70160   void * jresult ;
70161   Dali::BaseHandle arg1 ;
70162   Dali::BaseHandle *argp1 ;
70163   Dali::Toolkit::Model3dView result;
70164
70165   argp1 = (Dali::BaseHandle *)jarg1;
70166   if (!argp1) {
70167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70168     return 0;
70169   }
70170   arg1 = *argp1;
70171   {
70172     try {
70173       result = Dali::Toolkit::Model3dView::DownCast(arg1);
70174     } catch (std::out_of_range& e) {
70175       {
70176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70177       };
70178     } catch (std::exception& e) {
70179       {
70180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70181       };
70182     } catch (Dali::DaliException e) {
70183       {
70184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70185       };
70186     } catch (...) {
70187       {
70188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70189       };
70190     }
70191   }
70192
70193   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
70194   return jresult;
70195 }
70196
70197
70198 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
70199   int jresult ;
70200   int result;
70201
70202   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
70203   jresult = (int)result;
70204   return jresult;
70205 }
70206
70207
70208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
70209   int jresult ;
70210   int result;
70211
70212   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
70213   jresult = (int)result;
70214   return jresult;
70215 }
70216
70217
70218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
70219   int jresult ;
70220   int result;
70221
70222   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
70223   jresult = (int)result;
70224   return jresult;
70225 }
70226
70227
70228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
70229   int jresult ;
70230   int result;
70231
70232   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
70233   jresult = (int)result;
70234   return jresult;
70235 }
70236
70237
70238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
70239   int jresult ;
70240   int result;
70241
70242   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
70243   jresult = (int)result;
70244   return jresult;
70245 }
70246
70247
70248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
70249   int jresult ;
70250   int result;
70251
70252   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
70253   jresult = (int)result;
70254   return jresult;
70255 }
70256
70257
70258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
70259   int jresult ;
70260   int result;
70261
70262   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
70263   jresult = (int)result;
70264   return jresult;
70265 }
70266
70267
70268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
70269   int jresult ;
70270   int result;
70271
70272   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
70273   jresult = (int)result;
70274   return jresult;
70275 }
70276
70277
70278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
70279   int jresult ;
70280   int result;
70281
70282   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
70283   jresult = (int)result;
70284   return jresult;
70285 }
70286
70287
70288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
70289   void * jresult ;
70290   Dali::Toolkit::ScrollBar::Property *result = 0 ;
70291
70292   {
70293     try {
70294       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
70295     } catch (std::out_of_range& e) {
70296       {
70297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70298       };
70299     } catch (std::exception& e) {
70300       {
70301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70302       };
70303     } catch (Dali::DaliException e) {
70304       {
70305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70306       };
70307     } catch (...) {
70308       {
70309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70310       };
70311     }
70312   }
70313
70314   jresult = (void *)result;
70315   return jresult;
70316 }
70317
70318
70319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
70320   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
70321
70322   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
70323   {
70324     try {
70325       delete arg1;
70326     } catch (std::out_of_range& e) {
70327       {
70328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70329       };
70330     } catch (std::exception& e) {
70331       {
70332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70333       };
70334     } catch (Dali::DaliException e) {
70335       {
70336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70337       };
70338     } catch (...) {
70339       {
70340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70341       };
70342     }
70343   }
70344
70345 }
70346
70347
70348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
70349   void * jresult ;
70350   Dali::Toolkit::ScrollBar *result = 0 ;
70351
70352   {
70353     try {
70354       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
70355     } catch (std::out_of_range& e) {
70356       {
70357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70358       };
70359     } catch (std::exception& e) {
70360       {
70361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70362       };
70363     } catch (Dali::DaliException e) {
70364       {
70365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70366       };
70367     } catch (...) {
70368       {
70369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70370       };
70371     }
70372   }
70373
70374   jresult = (void *)result;
70375   return jresult;
70376 }
70377
70378
70379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
70380   void * jresult ;
70381   Dali::Toolkit::ScrollBar *arg1 = 0 ;
70382   Dali::Toolkit::ScrollBar *result = 0 ;
70383
70384   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70385   if (!arg1) {
70386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
70387     return 0;
70388   }
70389   {
70390     try {
70391       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
70392     } catch (std::out_of_range& e) {
70393       {
70394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70395       };
70396     } catch (std::exception& e) {
70397       {
70398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70399       };
70400     } catch (Dali::DaliException e) {
70401       {
70402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70403       };
70404     } catch (...) {
70405       {
70406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70407       };
70408     }
70409   }
70410
70411   jresult = (void *)result;
70412   return jresult;
70413 }
70414
70415
70416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
70417   void * jresult ;
70418   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70419   Dali::Toolkit::ScrollBar *arg2 = 0 ;
70420   Dali::Toolkit::ScrollBar *result = 0 ;
70421
70422   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70423   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
70424   if (!arg2) {
70425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
70426     return 0;
70427   }
70428   {
70429     try {
70430       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
70431     } catch (std::out_of_range& e) {
70432       {
70433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70434       };
70435     } catch (std::exception& e) {
70436       {
70437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70438       };
70439     } catch (Dali::DaliException e) {
70440       {
70441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70442       };
70443     } catch (...) {
70444       {
70445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70446       };
70447     }
70448   }
70449
70450   jresult = (void *)result;
70451   return jresult;
70452 }
70453
70454
70455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
70456   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70457
70458   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70459   {
70460     try {
70461       delete arg1;
70462     } catch (std::out_of_range& e) {
70463       {
70464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70465       };
70466     } catch (std::exception& e) {
70467       {
70468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70469       };
70470     } catch (Dali::DaliException e) {
70471       {
70472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70473       };
70474     } catch (...) {
70475       {
70476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70477       };
70478     }
70479   }
70480
70481 }
70482
70483
70484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
70485   void * jresult ;
70486   Dali::Toolkit::ScrollBar::Direction arg1 ;
70487   Dali::Toolkit::ScrollBar result;
70488
70489   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
70490   {
70491     try {
70492       result = Dali::Toolkit::ScrollBar::New(arg1);
70493     } catch (std::out_of_range& e) {
70494       {
70495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70496       };
70497     } catch (std::exception& e) {
70498       {
70499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70500       };
70501     } catch (Dali::DaliException e) {
70502       {
70503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70504       };
70505     } catch (...) {
70506       {
70507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70508       };
70509     }
70510   }
70511
70512   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
70513   return jresult;
70514 }
70515
70516
70517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
70518   void * jresult ;
70519   Dali::Toolkit::ScrollBar result;
70520
70521   {
70522     try {
70523       result = Dali::Toolkit::ScrollBar::New();
70524     } catch (std::out_of_range& e) {
70525       {
70526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70527       };
70528     } catch (std::exception& e) {
70529       {
70530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70531       };
70532     } catch (Dali::DaliException e) {
70533       {
70534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70535       };
70536     } catch (...) {
70537       {
70538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70539       };
70540     }
70541   }
70542
70543   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
70544   return jresult;
70545 }
70546
70547
70548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
70549   void * jresult ;
70550   Dali::BaseHandle arg1 ;
70551   Dali::BaseHandle *argp1 ;
70552   Dali::Toolkit::ScrollBar result;
70553
70554   argp1 = (Dali::BaseHandle *)jarg1;
70555   if (!argp1) {
70556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70557     return 0;
70558   }
70559   arg1 = *argp1;
70560   {
70561     try {
70562       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
70563     } catch (std::out_of_range& e) {
70564       {
70565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70566       };
70567     } catch (std::exception& e) {
70568       {
70569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70570       };
70571     } catch (Dali::DaliException e) {
70572       {
70573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70574       };
70575     } catch (...) {
70576       {
70577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70578       };
70579     }
70580   }
70581
70582   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
70583   return jresult;
70584 }
70585
70586
70587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
70588   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70589   Dali::Handle arg2 ;
70590   Dali::Property::Index arg3 ;
70591   Dali::Property::Index arg4 ;
70592   Dali::Property::Index arg5 ;
70593   Dali::Property::Index arg6 ;
70594   Dali::Handle *argp2 ;
70595
70596   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70597   argp2 = (Dali::Handle *)jarg2;
70598   if (!argp2) {
70599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
70600     return ;
70601   }
70602   arg2 = *argp2;
70603   arg3 = (Dali::Property::Index)jarg3;
70604   arg4 = (Dali::Property::Index)jarg4;
70605   arg5 = (Dali::Property::Index)jarg5;
70606   arg6 = (Dali::Property::Index)jarg6;
70607   {
70608     try {
70609       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
70610     } catch (std::out_of_range& e) {
70611       {
70612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70613       };
70614     } catch (std::exception& e) {
70615       {
70616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70617       };
70618     } catch (Dali::DaliException e) {
70619       {
70620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70621       };
70622     } catch (...) {
70623       {
70624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70625       };
70626     }
70627   }
70628
70629 }
70630
70631
70632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
70633   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70634   Dali::Actor arg2 ;
70635   Dali::Actor *argp2 ;
70636
70637   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70638   argp2 = (Dali::Actor *)jarg2;
70639   if (!argp2) {
70640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70641     return ;
70642   }
70643   arg2 = *argp2;
70644   {
70645     try {
70646       (arg1)->SetScrollIndicator(arg2);
70647     } catch (std::out_of_range& e) {
70648       {
70649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70650       };
70651     } catch (std::exception& e) {
70652       {
70653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70654       };
70655     } catch (Dali::DaliException e) {
70656       {
70657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70658       };
70659     } catch (...) {
70660       {
70661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70662       };
70663     }
70664   }
70665
70666 }
70667
70668
70669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
70670   void * jresult ;
70671   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70672   Dali::Actor result;
70673
70674   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70675   {
70676     try {
70677       result = (arg1)->GetScrollIndicator();
70678     } catch (std::out_of_range& e) {
70679       {
70680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70681       };
70682     } catch (std::exception& e) {
70683       {
70684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70685       };
70686     } catch (Dali::DaliException e) {
70687       {
70688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70689       };
70690     } catch (...) {
70691       {
70692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70693       };
70694     }
70695   }
70696
70697   jresult = new Dali::Actor((const Dali::Actor &)result);
70698   return jresult;
70699 }
70700
70701
70702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
70703   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70704   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
70705
70706   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70707   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
70708   if (!arg2) {
70709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
70710     return ;
70711   }
70712   {
70713     try {
70714       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
70715     } catch (std::out_of_range& e) {
70716       {
70717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70718       };
70719     } catch (std::exception& e) {
70720       {
70721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70722       };
70723     } catch (Dali::DaliException e) {
70724       {
70725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70726       };
70727     } catch (...) {
70728       {
70729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70730       };
70731     }
70732   }
70733
70734 }
70735
70736
70737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
70738   void * jresult ;
70739   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70740
70741   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70742   {
70743     try {
70744       jresult = new Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true >((const Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > &)(((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollPositionIntervals()));
70745     } catch (std::out_of_range& e) {
70746       {
70747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70748       };
70749     } catch (std::exception& e) {
70750       {
70751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70752       };
70753     } catch (...) {
70754       {
70755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70756       };
70757     }
70758   }
70759   return jresult;
70760 }
70761
70762
70763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
70764   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70765   Dali::Toolkit::ScrollBar::Direction arg2 ;
70766
70767   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70768   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
70769   {
70770     try {
70771       (arg1)->SetScrollDirection(arg2);
70772     } catch (std::out_of_range& e) {
70773       {
70774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70775       };
70776     } catch (std::exception& e) {
70777       {
70778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70779       };
70780     } catch (Dali::DaliException e) {
70781       {
70782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70783       };
70784     } catch (...) {
70785       {
70786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70787       };
70788     }
70789   }
70790
70791 }
70792
70793
70794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
70795   int jresult ;
70796   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70797   Dali::Toolkit::ScrollBar::Direction result;
70798
70799   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70800   {
70801     try {
70802       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
70803     } catch (std::out_of_range& e) {
70804       {
70805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70806       };
70807     } catch (std::exception& e) {
70808       {
70809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70810       };
70811     } catch (Dali::DaliException e) {
70812       {
70813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70814       };
70815     } catch (...) {
70816       {
70817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70818       };
70819     }
70820   }
70821
70822   jresult = (int)result;
70823   return jresult;
70824 }
70825
70826
70827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
70828   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70829   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
70830
70831   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70832   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
70833   {
70834     try {
70835       (arg1)->SetIndicatorHeightPolicy(arg2);
70836     } catch (std::out_of_range& e) {
70837       {
70838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70839       };
70840     } catch (std::exception& e) {
70841       {
70842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70843       };
70844     } catch (Dali::DaliException e) {
70845       {
70846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70847       };
70848     } catch (...) {
70849       {
70850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70851       };
70852     }
70853   }
70854
70855 }
70856
70857
70858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
70859   int jresult ;
70860   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70861   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
70862
70863   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70864   {
70865     try {
70866       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
70867     } catch (std::out_of_range& e) {
70868       {
70869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70870       };
70871     } catch (std::exception& e) {
70872       {
70873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70874       };
70875     } catch (Dali::DaliException e) {
70876       {
70877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70878       };
70879     } catch (...) {
70880       {
70881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70882       };
70883     }
70884   }
70885
70886   jresult = (int)result;
70887   return jresult;
70888 }
70889
70890
70891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
70892   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70893   float arg2 ;
70894
70895   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70896   arg2 = (float)jarg2;
70897   {
70898     try {
70899       (arg1)->SetIndicatorFixedHeight(arg2);
70900     } catch (std::out_of_range& e) {
70901       {
70902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70903       };
70904     } catch (std::exception& e) {
70905       {
70906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70907       };
70908     } catch (Dali::DaliException e) {
70909       {
70910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70911       };
70912     } catch (...) {
70913       {
70914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70915       };
70916     }
70917   }
70918
70919 }
70920
70921
70922 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
70923   float jresult ;
70924   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70925   float result;
70926
70927   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70928   {
70929     try {
70930       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
70931     } catch (std::out_of_range& e) {
70932       {
70933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70934       };
70935     } catch (std::exception& e) {
70936       {
70937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70938       };
70939     } catch (Dali::DaliException e) {
70940       {
70941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70942       };
70943     } catch (...) {
70944       {
70945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70946       };
70947     }
70948   }
70949
70950   jresult = result;
70951   return jresult;
70952 }
70953
70954
70955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
70956   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70957   float arg2 ;
70958
70959   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70960   arg2 = (float)jarg2;
70961   {
70962     try {
70963       (arg1)->SetIndicatorShowDuration(arg2);
70964     } catch (std::out_of_range& e) {
70965       {
70966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70967       };
70968     } catch (std::exception& e) {
70969       {
70970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70971       };
70972     } catch (Dali::DaliException e) {
70973       {
70974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70975       };
70976     } catch (...) {
70977       {
70978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70979       };
70980     }
70981   }
70982
70983 }
70984
70985
70986 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
70987   float jresult ;
70988   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
70989   float result;
70990
70991   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
70992   {
70993     try {
70994       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
70995     } catch (std::out_of_range& e) {
70996       {
70997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70998       };
70999     } catch (std::exception& e) {
71000       {
71001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71002       };
71003     } catch (Dali::DaliException e) {
71004       {
71005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71006       };
71007     } catch (...) {
71008       {
71009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71010       };
71011     }
71012   }
71013
71014   jresult = result;
71015   return jresult;
71016 }
71017
71018
71019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
71020   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71021   float arg2 ;
71022
71023   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71024   arg2 = (float)jarg2;
71025   {
71026     try {
71027       (arg1)->SetIndicatorHideDuration(arg2);
71028     } catch (std::out_of_range& e) {
71029       {
71030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71031       };
71032     } catch (std::exception& e) {
71033       {
71034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71035       };
71036     } catch (Dali::DaliException e) {
71037       {
71038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71039       };
71040     } catch (...) {
71041       {
71042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71043       };
71044     }
71045   }
71046
71047 }
71048
71049
71050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
71051   float jresult ;
71052   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71053   float result;
71054
71055   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71056   {
71057     try {
71058       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
71059     } catch (std::out_of_range& e) {
71060       {
71061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71062       };
71063     } catch (std::exception& e) {
71064       {
71065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71066       };
71067     } catch (Dali::DaliException e) {
71068       {
71069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71070       };
71071     } catch (...) {
71072       {
71073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71074       };
71075     }
71076   }
71077
71078   jresult = result;
71079   return jresult;
71080 }
71081
71082
71083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
71084   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71085
71086   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71087   {
71088     try {
71089       (arg1)->ShowIndicator();
71090     } catch (std::out_of_range& e) {
71091       {
71092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71093       };
71094     } catch (std::exception& e) {
71095       {
71096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71097       };
71098     } catch (Dali::DaliException e) {
71099       {
71100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71101       };
71102     } catch (...) {
71103       {
71104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71105       };
71106     }
71107   }
71108
71109 }
71110
71111
71112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
71113   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71114
71115   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71116   {
71117     try {
71118       (arg1)->HideIndicator();
71119     } catch (std::out_of_range& e) {
71120       {
71121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71122       };
71123     } catch (std::exception& e) {
71124       {
71125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71126       };
71127     } catch (Dali::DaliException e) {
71128       {
71129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71130       };
71131     } catch (...) {
71132       {
71133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71134       };
71135     }
71136   }
71137
71138 }
71139
71140
71141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
71142   void * jresult ;
71143   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71144   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
71145
71146   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71147   {
71148     try {
71149       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
71150     } catch (std::out_of_range& e) {
71151       {
71152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71153       };
71154     } catch (std::exception& e) {
71155       {
71156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71157       };
71158     } catch (Dali::DaliException e) {
71159       {
71160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71161       };
71162     } catch (...) {
71163       {
71164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71165       };
71166     }
71167   }
71168
71169   jresult = (void *)result;
71170   return jresult;
71171 }
71172
71173
71174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
71175   void * jresult ;
71176   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
71177   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
71178
71179   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
71180   {
71181     try {
71182       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
71183     } catch (std::out_of_range& e) {
71184       {
71185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71186       };
71187     } catch (std::exception& e) {
71188       {
71189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71190       };
71191     } catch (Dali::DaliException e) {
71192       {
71193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71194       };
71195     } catch (...) {
71196       {
71197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71198       };
71199     }
71200   }
71201
71202   jresult = (void *)result;
71203   return jresult;
71204 }
71205
71206
71207 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
71208   int jresult ;
71209   int result;
71210
71211   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
71212   jresult = (int)result;
71213   return jresult;
71214 }
71215
71216
71217 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
71218   int jresult ;
71219   int result;
71220
71221   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
71222   jresult = (int)result;
71223   return jresult;
71224 }
71225
71226
71227 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
71228   int jresult ;
71229   int result;
71230
71231   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
71232   jresult = (int)result;
71233   return jresult;
71234 }
71235
71236
71237 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
71238   int jresult ;
71239   int result;
71240
71241   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
71242   jresult = (int)result;
71243   return jresult;
71244 }
71245
71246
71247 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
71248   int jresult ;
71249   int result;
71250
71251   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
71252   jresult = (int)result;
71253   return jresult;
71254 }
71255
71256
71257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
71258   int jresult ;
71259   int result;
71260
71261   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
71262   jresult = (int)result;
71263   return jresult;
71264 }
71265
71266
71267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
71268   int jresult ;
71269   int result;
71270
71271   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
71272   jresult = (int)result;
71273   return jresult;
71274 }
71275
71276
71277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
71278   int jresult ;
71279   int result;
71280
71281   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
71282   jresult = (int)result;
71283   return jresult;
71284 }
71285
71286
71287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
71288   int jresult ;
71289   int result;
71290
71291   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
71292   jresult = (int)result;
71293   return jresult;
71294 }
71295
71296
71297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
71298   int jresult ;
71299   int result;
71300
71301   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
71302   jresult = (int)result;
71303   return jresult;
71304 }
71305
71306
71307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
71308   int jresult ;
71309   int result;
71310
71311   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
71312   jresult = (int)result;
71313   return jresult;
71314 }
71315
71316
71317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
71318   int jresult ;
71319   int result;
71320
71321   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
71322   jresult = (int)result;
71323   return jresult;
71324 }
71325
71326
71327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
71328   int jresult ;
71329   int result;
71330
71331   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
71332   jresult = (int)result;
71333   return jresult;
71334 }
71335
71336
71337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
71338   int jresult ;
71339   int result;
71340
71341   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
71342   jresult = (int)result;
71343   return jresult;
71344 }
71345
71346
71347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
71348   void * jresult ;
71349   Dali::Toolkit::Scrollable::Property *result = 0 ;
71350
71351   {
71352     try {
71353       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
71354     } catch (std::out_of_range& e) {
71355       {
71356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71357       };
71358     } catch (std::exception& e) {
71359       {
71360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71361       };
71362     } catch (Dali::DaliException e) {
71363       {
71364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71365       };
71366     } catch (...) {
71367       {
71368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71369       };
71370     }
71371   }
71372
71373   jresult = (void *)result;
71374   return jresult;
71375 }
71376
71377
71378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
71379   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
71380
71381   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
71382   {
71383     try {
71384       delete arg1;
71385     } catch (std::out_of_range& e) {
71386       {
71387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71388       };
71389     } catch (std::exception& e) {
71390       {
71391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71392       };
71393     } catch (Dali::DaliException e) {
71394       {
71395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71396       };
71397     } catch (...) {
71398       {
71399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71400       };
71401     }
71402   }
71403
71404 }
71405
71406
71407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
71408   void * jresult ;
71409   Dali::Toolkit::Scrollable *result = 0 ;
71410
71411   {
71412     try {
71413       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
71414     } catch (std::out_of_range& e) {
71415       {
71416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71417       };
71418     } catch (std::exception& e) {
71419       {
71420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71421       };
71422     } catch (Dali::DaliException e) {
71423       {
71424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71425       };
71426     } catch (...) {
71427       {
71428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71429       };
71430     }
71431   }
71432
71433   jresult = (void *)result;
71434   return jresult;
71435 }
71436
71437
71438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
71439   void * jresult ;
71440   Dali::Toolkit::Scrollable *arg1 = 0 ;
71441   Dali::Toolkit::Scrollable *result = 0 ;
71442
71443   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71444   if (!arg1) {
71445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
71446     return 0;
71447   }
71448   {
71449     try {
71450       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
71451     } catch (std::out_of_range& e) {
71452       {
71453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71454       };
71455     } catch (std::exception& e) {
71456       {
71457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71458       };
71459     } catch (Dali::DaliException e) {
71460       {
71461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71462       };
71463     } catch (...) {
71464       {
71465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71466       };
71467     }
71468   }
71469
71470   jresult = (void *)result;
71471   return jresult;
71472 }
71473
71474
71475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
71476   void * jresult ;
71477   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71478   Dali::Toolkit::Scrollable *arg2 = 0 ;
71479   Dali::Toolkit::Scrollable *result = 0 ;
71480
71481   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71482   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
71483   if (!arg2) {
71484     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
71485     return 0;
71486   }
71487   {
71488     try {
71489       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
71490     } catch (std::out_of_range& e) {
71491       {
71492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71493       };
71494     } catch (std::exception& e) {
71495       {
71496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71497       };
71498     } catch (Dali::DaliException e) {
71499       {
71500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71501       };
71502     } catch (...) {
71503       {
71504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71505       };
71506     }
71507   }
71508
71509   jresult = (void *)result;
71510   return jresult;
71511 }
71512
71513
71514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
71515   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71516
71517   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71518   {
71519     try {
71520       delete arg1;
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 (Dali::DaliException e) {
71530       {
71531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71532       };
71533     } catch (...) {
71534       {
71535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71536       };
71537     }
71538   }
71539
71540 }
71541
71542
71543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
71544   void * jresult ;
71545   Dali::BaseHandle arg1 ;
71546   Dali::BaseHandle *argp1 ;
71547   Dali::Toolkit::Scrollable result;
71548
71549   argp1 = (Dali::BaseHandle *)jarg1;
71550   if (!argp1) {
71551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71552     return 0;
71553   }
71554   arg1 = *argp1;
71555   {
71556     try {
71557       result = Dali::Toolkit::Scrollable::DownCast(arg1);
71558     } catch (std::out_of_range& e) {
71559       {
71560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71561       };
71562     } catch (std::exception& e) {
71563       {
71564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71565       };
71566     } catch (Dali::DaliException e) {
71567       {
71568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71569       };
71570     } catch (...) {
71571       {
71572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71573       };
71574     }
71575   }
71576
71577   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
71578   return jresult;
71579 }
71580
71581
71582 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
71583   unsigned int jresult ;
71584   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71585   bool result;
71586
71587   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71588   {
71589     try {
71590       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
71591     } catch (std::out_of_range& e) {
71592       {
71593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71594       };
71595     } catch (std::exception& e) {
71596       {
71597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71598       };
71599     } catch (Dali::DaliException e) {
71600       {
71601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71602       };
71603     } catch (...) {
71604       {
71605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71606       };
71607     }
71608   }
71609
71610   jresult = result;
71611   return jresult;
71612 }
71613
71614
71615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
71616   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71617   bool arg2 ;
71618
71619   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71620   arg2 = jarg2 ? true : false;
71621   {
71622     try {
71623       (arg1)->SetOvershootEnabled(arg2);
71624     } catch (std::out_of_range& e) {
71625       {
71626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71627       };
71628     } catch (std::exception& e) {
71629       {
71630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71631       };
71632     } catch (Dali::DaliException e) {
71633       {
71634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71635       };
71636     } catch (...) {
71637       {
71638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71639       };
71640     }
71641   }
71642
71643 }
71644
71645
71646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
71647   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71648   Dali::Vector4 *arg2 = 0 ;
71649
71650   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71651   arg2 = (Dali::Vector4 *)jarg2;
71652   if (!arg2) {
71653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
71654     return ;
71655   }
71656   {
71657     try {
71658       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
71659     } catch (std::out_of_range& e) {
71660       {
71661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71662       };
71663     } catch (std::exception& e) {
71664       {
71665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71666       };
71667     } catch (Dali::DaliException e) {
71668       {
71669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71670       };
71671     } catch (...) {
71672       {
71673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71674       };
71675     }
71676   }
71677
71678 }
71679
71680
71681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
71682   void * jresult ;
71683   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71684   Dali::Vector4 result;
71685
71686   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71687   {
71688     try {
71689       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
71690     } catch (std::out_of_range& e) {
71691       {
71692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71693       };
71694     } catch (std::exception& e) {
71695       {
71696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71697       };
71698     } catch (Dali::DaliException e) {
71699       {
71700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71701       };
71702     } catch (...) {
71703       {
71704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71705       };
71706     }
71707   }
71708
71709   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
71710   return jresult;
71711 }
71712
71713
71714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
71715   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71716   float arg2 ;
71717
71718   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71719   arg2 = (float)jarg2;
71720   {
71721     try {
71722       (arg1)->SetOvershootAnimationSpeed(arg2);
71723     } catch (std::out_of_range& e) {
71724       {
71725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71726       };
71727     } catch (std::exception& e) {
71728       {
71729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71730       };
71731     } catch (Dali::DaliException e) {
71732       {
71733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71734       };
71735     } catch (...) {
71736       {
71737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71738       };
71739     }
71740   }
71741
71742 }
71743
71744
71745 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
71746   float jresult ;
71747   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71748   float result;
71749
71750   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71751   {
71752     try {
71753       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
71754     } catch (std::out_of_range& e) {
71755       {
71756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71757       };
71758     } catch (std::exception& e) {
71759       {
71760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71761       };
71762     } catch (Dali::DaliException e) {
71763       {
71764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71765       };
71766     } catch (...) {
71767       {
71768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71769       };
71770     }
71771   }
71772
71773   jresult = result;
71774   return jresult;
71775 }
71776
71777
71778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
71779   void * jresult ;
71780   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71781   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
71782
71783   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71784   {
71785     try {
71786       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
71787     } catch (std::out_of_range& e) {
71788       {
71789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71790       };
71791     } catch (std::exception& e) {
71792       {
71793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71794       };
71795     } catch (Dali::DaliException e) {
71796       {
71797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71798       };
71799     } catch (...) {
71800       {
71801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71802       };
71803     }
71804   }
71805
71806   jresult = (void *)result;
71807   return jresult;
71808 }
71809
71810
71811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
71812   void * jresult ;
71813   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71814   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
71815
71816   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71817   {
71818     try {
71819       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
71820     } catch (std::out_of_range& e) {
71821       {
71822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71823       };
71824     } catch (std::exception& e) {
71825       {
71826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71827       };
71828     } catch (Dali::DaliException e) {
71829       {
71830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71831       };
71832     } catch (...) {
71833       {
71834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71835       };
71836     }
71837   }
71838
71839   jresult = (void *)result;
71840   return jresult;
71841 }
71842
71843
71844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
71845   void * jresult ;
71846   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
71847   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
71848
71849   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
71850   {
71851     try {
71852       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
71853     } catch (std::out_of_range& e) {
71854       {
71855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71856       };
71857     } catch (std::exception& e) {
71858       {
71859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71860       };
71861     } catch (Dali::DaliException e) {
71862       {
71863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71864       };
71865     } catch (...) {
71866       {
71867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71868       };
71869     }
71870   }
71871
71872   jresult = (void *)result;
71873   return jresult;
71874 }
71875
71876
71877 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
71878   unsigned int jresult ;
71879   Dali::Toolkit::ControlOrientation::Type arg1 ;
71880   bool result;
71881
71882   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
71883   {
71884     try {
71885       result = (bool)Dali::Toolkit::IsVertical(arg1);
71886     } catch (std::out_of_range& e) {
71887       {
71888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71889       };
71890     } catch (std::exception& e) {
71891       {
71892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71893       };
71894     } catch (Dali::DaliException e) {
71895       {
71896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71897       };
71898     } catch (...) {
71899       {
71900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71901       };
71902     }
71903   }
71904
71905   jresult = result;
71906   return jresult;
71907 }
71908
71909
71910 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
71911   unsigned int jresult ;
71912   Dali::Toolkit::ControlOrientation::Type arg1 ;
71913   bool result;
71914
71915   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
71916   {
71917     try {
71918       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
71919     } catch (std::out_of_range& e) {
71920       {
71921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71922       };
71923     } catch (std::exception& e) {
71924       {
71925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71926       };
71927     } catch (Dali::DaliException e) {
71928       {
71929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71930       };
71931     } catch (...) {
71932       {
71933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71934       };
71935     }
71936   }
71937
71938   jresult = result;
71939   return jresult;
71940 }
71941
71942
71943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
71944   void * jresult ;
71945   unsigned int arg1 ;
71946   unsigned int arg2 ;
71947   Dali::Toolkit::ItemRange *result = 0 ;
71948
71949   arg1 = (unsigned int)jarg1;
71950   arg2 = (unsigned int)jarg2;
71951   {
71952     try {
71953       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
71954     } catch (std::out_of_range& e) {
71955       {
71956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71957       };
71958     } catch (std::exception& e) {
71959       {
71960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71961       };
71962     } catch (Dali::DaliException e) {
71963       {
71964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71965       };
71966     } catch (...) {
71967       {
71968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71969       };
71970     }
71971   }
71972
71973   jresult = (void *)result;
71974   return jresult;
71975 }
71976
71977
71978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
71979   void * jresult ;
71980   Dali::Toolkit::ItemRange *arg1 = 0 ;
71981   Dali::Toolkit::ItemRange *result = 0 ;
71982
71983   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
71984   if (!arg1) {
71985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
71986     return 0;
71987   }
71988   {
71989     try {
71990       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
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 (Dali::DaliException e) {
72000       {
72001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72002       };
72003     } catch (...) {
72004       {
72005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72006       };
72007     }
72008   }
72009
72010   jresult = (void *)result;
72011   return jresult;
72012 }
72013
72014
72015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
72016   void * jresult ;
72017   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
72018   Dali::Toolkit::ItemRange *arg2 = 0 ;
72019   Dali::Toolkit::ItemRange *result = 0 ;
72020
72021   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
72022   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72023   if (!arg2) {
72024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
72025     return 0;
72026   }
72027   {
72028     try {
72029       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
72030     } catch (std::out_of_range& e) {
72031       {
72032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72033       };
72034     } catch (std::exception& e) {
72035       {
72036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72037       };
72038     } catch (Dali::DaliException e) {
72039       {
72040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72041       };
72042     } catch (...) {
72043       {
72044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72045       };
72046     }
72047   }
72048
72049   jresult = (void *)result;
72050   return jresult;
72051 }
72052
72053
72054 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
72055   unsigned int jresult ;
72056   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
72057   unsigned int arg2 ;
72058   bool result;
72059
72060   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
72061   arg2 = (unsigned int)jarg2;
72062   {
72063     try {
72064       result = (bool)(arg1)->Within(arg2);
72065     } catch (std::out_of_range& e) {
72066       {
72067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72068       };
72069     } catch (std::exception& e) {
72070       {
72071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72072       };
72073     } catch (Dali::DaliException e) {
72074       {
72075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72076       };
72077     } catch (...) {
72078       {
72079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72080       };
72081     }
72082   }
72083
72084   jresult = result;
72085   return jresult;
72086 }
72087
72088
72089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
72090   void * jresult ;
72091   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
72092   Dali::Toolkit::ItemRange *arg2 = 0 ;
72093   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
72094
72095   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
72096   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72097   if (!arg2) {
72098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
72099     return 0;
72100   }
72101   {
72102     try {
72103       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
72104     } catch (std::out_of_range& e) {
72105       {
72106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72107       };
72108     } catch (std::exception& e) {
72109       {
72110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72111       };
72112     } catch (Dali::DaliException e) {
72113       {
72114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72115       };
72116     } catch (...) {
72117       {
72118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72119       };
72120     }
72121   }
72122
72123   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
72124   return jresult;
72125 }
72126
72127
72128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
72129   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
72130   unsigned int arg2 ;
72131
72132   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
72133   arg2 = (unsigned int)jarg2;
72134   if (arg1) (arg1)->begin = arg2;
72135 }
72136
72137
72138 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
72139   unsigned int jresult ;
72140   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
72141   unsigned int result;
72142
72143   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
72144   result = (unsigned int) ((arg1)->begin);
72145   jresult = result;
72146   return jresult;
72147 }
72148
72149
72150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
72151   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
72152   unsigned int arg2 ;
72153
72154   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
72155   arg2 = (unsigned int)jarg2;
72156   if (arg1) (arg1)->end = arg2;
72157 }
72158
72159
72160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
72161   unsigned int jresult ;
72162   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
72163   unsigned int result;
72164
72165   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
72166   result = (unsigned int) ((arg1)->end);
72167   jresult = result;
72168   return jresult;
72169 }
72170
72171
72172 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
72173   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
72174
72175   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
72176   {
72177     try {
72178       delete arg1;
72179     } catch (std::out_of_range& e) {
72180       {
72181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72182       };
72183     } catch (std::exception& e) {
72184       {
72185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72186       };
72187     } catch (Dali::DaliException e) {
72188       {
72189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72190       };
72191     } catch (...) {
72192       {
72193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72194       };
72195     }
72196   }
72197
72198 }
72199
72200
72201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
72202   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72203
72204   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72205   {
72206     try {
72207       delete arg1;
72208     } catch (std::out_of_range& e) {
72209       {
72210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72211       };
72212     } catch (std::exception& e) {
72213       {
72214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72215       };
72216     } catch (Dali::DaliException e) {
72217       {
72218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72219       };
72220     } catch (...) {
72221       {
72222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72223       };
72224     }
72225   }
72226
72227 }
72228
72229
72230 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
72231   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72232   Dali::Toolkit::ControlOrientation::Type arg2 ;
72233
72234   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72235   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
72236   {
72237     try {
72238       (arg1)->SetOrientation(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 (Dali::DaliException e) {
72248       {
72249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72250       };
72251     } catch (...) {
72252       {
72253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72254       };
72255     }
72256   }
72257
72258 }
72259
72260
72261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
72262   int jresult ;
72263   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72264   Dali::Toolkit::ControlOrientation::Type result;
72265
72266   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72267   {
72268     try {
72269       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
72270     } catch (std::out_of_range& e) {
72271       {
72272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72273       };
72274     } catch (std::exception& e) {
72275       {
72276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72277       };
72278     } catch (Dali::DaliException e) {
72279       {
72280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72281       };
72282     } catch (...) {
72283       {
72284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72285       };
72286     }
72287   }
72288
72289   jresult = (int)result;
72290   return jresult;
72291 }
72292
72293
72294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
72295   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72296   Dali::Property::Map *arg2 = 0 ;
72297
72298   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72299   arg2 = (Dali::Property::Map *)jarg2;
72300   if (!arg2) {
72301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
72302     return ;
72303   }
72304   {
72305     try {
72306       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
72307     } catch (std::out_of_range& e) {
72308       {
72309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72310       };
72311     } catch (std::exception& e) {
72312       {
72313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72314       };
72315     } catch (Dali::DaliException e) {
72316       {
72317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72318       };
72319     } catch (...) {
72320       {
72321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72322       };
72323     }
72324   }
72325
72326 }
72327
72328
72329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
72330   void * jresult ;
72331   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72332   Dali::Property::Map result;
72333
72334   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72335   {
72336     try {
72337       result = (arg1)->GetLayoutProperties();
72338     } catch (std::out_of_range& e) {
72339       {
72340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72341       };
72342     } catch (std::exception& e) {
72343       {
72344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72345       };
72346     } catch (Dali::DaliException e) {
72347       {
72348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72349       };
72350     } catch (...) {
72351       {
72352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72353       };
72354     }
72355   }
72356
72357   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
72358   return jresult;
72359 }
72360
72361
72362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
72363   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72364   unsigned int arg2 ;
72365   Dali::Vector3 *arg3 = 0 ;
72366   Dali::Vector3 *arg4 = 0 ;
72367
72368   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72369   arg2 = (unsigned int)jarg2;
72370   arg3 = (Dali::Vector3 *)jarg3;
72371   if (!arg3) {
72372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72373     return ;
72374   }
72375   arg4 = (Dali::Vector3 *)jarg4;
72376   if (!arg4) {
72377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72378     return ;
72379   }
72380   {
72381     try {
72382       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
72383     } catch (std::out_of_range& e) {
72384       {
72385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72386       };
72387     } catch (std::exception& e) {
72388       {
72389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72390       };
72391     } catch (Dali::DaliException e) {
72392       {
72393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72394       };
72395     } catch (...) {
72396       {
72397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72398       };
72399     }
72400   }
72401
72402 }
72403
72404
72405 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
72406   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72407   Dali::Vector3 *arg2 = 0 ;
72408
72409   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72410   arg2 = (Dali::Vector3 *)jarg2;
72411   if (!arg2) {
72412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72413     return ;
72414   }
72415   {
72416     try {
72417       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
72418     } catch (std::out_of_range& e) {
72419       {
72420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72421       };
72422     } catch (std::exception& e) {
72423       {
72424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72425       };
72426     } catch (Dali::DaliException e) {
72427       {
72428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72429       };
72430     } catch (...) {
72431       {
72432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72433       };
72434     }
72435   }
72436
72437 }
72438
72439
72440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
72441   float jresult ;
72442   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72443   unsigned int arg2 ;
72444   Dali::Vector3 arg3 ;
72445   Dali::Vector3 *argp3 ;
72446   float result;
72447
72448   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72449   arg2 = (unsigned int)jarg2;
72450   argp3 = (Dali::Vector3 *)jarg3;
72451   if (!argp3) {
72452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
72453     return 0;
72454   }
72455   arg3 = *argp3;
72456   {
72457     try {
72458       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
72459     } catch (std::out_of_range& e) {
72460       {
72461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72462       };
72463     } catch (std::exception& e) {
72464       {
72465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72466       };
72467     } catch (Dali::DaliException e) {
72468       {
72469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72470       };
72471     } catch (...) {
72472       {
72473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72474       };
72475     }
72476   }
72477
72478   jresult = result;
72479   return jresult;
72480 }
72481
72482
72483 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
72484   float jresult ;
72485   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72486   float arg2 ;
72487   float result;
72488
72489   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72490   arg2 = (float)jarg2;
72491   {
72492     try {
72493       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
72494     } catch (std::out_of_range& e) {
72495       {
72496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72497       };
72498     } catch (std::exception& e) {
72499       {
72500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72501       };
72502     } catch (Dali::DaliException e) {
72503       {
72504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72505       };
72506     } catch (...) {
72507       {
72508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72509       };
72510     }
72511   }
72512
72513   jresult = result;
72514   return jresult;
72515 }
72516
72517
72518 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
72519   float jresult ;
72520   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72521   unsigned int arg2 ;
72522   float result;
72523
72524   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72525   arg2 = (unsigned int)jarg2;
72526   {
72527     try {
72528       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
72529     } catch (std::out_of_range& e) {
72530       {
72531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72532       };
72533     } catch (std::exception& e) {
72534       {
72535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72536       };
72537     } catch (Dali::DaliException e) {
72538       {
72539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72540       };
72541     } catch (...) {
72542       {
72543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72544       };
72545     }
72546   }
72547
72548   jresult = result;
72549   return jresult;
72550 }
72551
72552
72553 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
72554   void * jresult ;
72555   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72556   float arg2 ;
72557   Dali::Vector3 arg3 ;
72558   Dali::Vector3 *argp3 ;
72559   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
72560
72561   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72562   arg2 = (float)jarg2;
72563   argp3 = (Dali::Vector3 *)jarg3;
72564   if (!argp3) {
72565     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
72566     return 0;
72567   }
72568   arg3 = *argp3;
72569   {
72570     try {
72571       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
72572     } catch (std::out_of_range& e) {
72573       {
72574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72575       };
72576     } catch (std::exception& e) {
72577       {
72578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72579       };
72580     } catch (Dali::DaliException e) {
72581       {
72582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72583       };
72584     } catch (...) {
72585       {
72586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72587       };
72588     }
72589   }
72590
72591   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
72592   return jresult;
72593 }
72594
72595
72596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
72597   float jresult ;
72598   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72599   int arg2 ;
72600   float arg3 ;
72601   Dali::Vector3 *arg4 = 0 ;
72602   float result;
72603
72604   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72605   arg2 = (int)jarg2;
72606   arg3 = (float)jarg3;
72607   arg4 = (Dali::Vector3 *)jarg4;
72608   if (!arg4) {
72609     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72610     return 0;
72611   }
72612   {
72613     try {
72614       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
72615     } catch (std::out_of_range& e) {
72616       {
72617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72618       };
72619     } catch (std::exception& e) {
72620       {
72621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72622       };
72623     } catch (Dali::DaliException e) {
72624       {
72625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72626       };
72627     } catch (...) {
72628       {
72629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72630       };
72631     }
72632   }
72633
72634   jresult = result;
72635   return jresult;
72636 }
72637
72638
72639 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
72640   unsigned int jresult ;
72641   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72642   Dali::Vector3 arg2 ;
72643   Dali::Vector3 *argp2 ;
72644   unsigned int result;
72645
72646   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72647   argp2 = (Dali::Vector3 *)jarg2;
72648   if (!argp2) {
72649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
72650     return 0;
72651   }
72652   arg2 = *argp2;
72653   {
72654     try {
72655       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
72656     } catch (std::out_of_range& e) {
72657       {
72658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72659       };
72660     } catch (std::exception& e) {
72661       {
72662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72663       };
72664     } catch (Dali::DaliException e) {
72665       {
72666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72667       };
72668     } catch (...) {
72669       {
72670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72671       };
72672     }
72673   }
72674
72675   jresult = result;
72676   return jresult;
72677 }
72678
72679
72680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
72681   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72682   unsigned int arg2 ;
72683   Dali::Vector3 *arg3 = 0 ;
72684   Dali::Vector3 *arg4 = 0 ;
72685
72686   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72687   arg2 = (unsigned int)jarg2;
72688   arg3 = (Dali::Vector3 *)jarg3;
72689   if (!arg3) {
72690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72691     return ;
72692   }
72693   arg4 = (Dali::Vector3 *)jarg4;
72694   if (!arg4) {
72695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72696     return ;
72697   }
72698   {
72699     try {
72700       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
72701     } catch (std::out_of_range& e) {
72702       {
72703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72704       };
72705     } catch (std::exception& e) {
72706       {
72707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72708       };
72709     } catch (Dali::DaliException e) {
72710       {
72711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72712       };
72713     } catch (...) {
72714       {
72715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72716       };
72717     }
72718   }
72719
72720 }
72721
72722
72723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
72724   void * jresult ;
72725   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72726   Dali::Degree result;
72727
72728   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72729   {
72730     try {
72731       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
72732     } catch (std::out_of_range& e) {
72733       {
72734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72735       };
72736     } catch (std::exception& e) {
72737       {
72738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72739       };
72740     } catch (Dali::DaliException e) {
72741       {
72742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72743       };
72744     } catch (...) {
72745       {
72746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72747       };
72748     }
72749   }
72750
72751   jresult = new Dali::Degree((const Dali::Degree &)result);
72752   return jresult;
72753 }
72754
72755
72756 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
72757   float jresult ;
72758   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72759   float result;
72760
72761   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72762   {
72763     try {
72764       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
72765     } catch (std::out_of_range& e) {
72766       {
72767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72768       };
72769     } catch (std::exception& e) {
72770       {
72771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72772       };
72773     } catch (Dali::DaliException e) {
72774       {
72775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72776       };
72777     } catch (...) {
72778       {
72779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72780       };
72781     }
72782   }
72783
72784   jresult = result;
72785   return jresult;
72786 }
72787
72788
72789 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
72790   float jresult ;
72791   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72792   float result;
72793
72794   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72795   {
72796     try {
72797       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
72798     } catch (std::out_of_range& e) {
72799       {
72800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72801       };
72802     } catch (std::exception& e) {
72803       {
72804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72805       };
72806     } catch (Dali::DaliException e) {
72807       {
72808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72809       };
72810     } catch (...) {
72811       {
72812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72813       };
72814     }
72815   }
72816
72817   jresult = result;
72818   return jresult;
72819 }
72820
72821
72822 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
72823   float jresult ;
72824   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72825   float result;
72826
72827   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72828   {
72829     try {
72830       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
72831     } catch (std::out_of_range& e) {
72832       {
72833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72834       };
72835     } catch (std::exception& e) {
72836       {
72837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72838       };
72839     } catch (Dali::DaliException e) {
72840       {
72841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72842       };
72843     } catch (...) {
72844       {
72845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72846       };
72847     }
72848   }
72849
72850   jresult = result;
72851   return jresult;
72852 }
72853
72854
72855 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
72856   int jresult ;
72857   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72858   int arg2 ;
72859   int arg3 ;
72860   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
72861   bool arg5 ;
72862   int result;
72863
72864   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72865   arg2 = (int)jarg2;
72866   arg3 = (int)jarg3;
72867   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
72868   arg5 = jarg5 ? true : false;
72869   {
72870     try {
72871       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
72872     } catch (std::out_of_range& e) {
72873       {
72874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72875       };
72876     } catch (std::exception& e) {
72877       {
72878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72879       };
72880     } catch (Dali::DaliException e) {
72881       {
72882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72883       };
72884     } catch (...) {
72885       {
72886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72887       };
72888     }
72889   }
72890
72891   jresult = result;
72892   return jresult;
72893 }
72894
72895
72896 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
72897   float jresult ;
72898   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72899   float result;
72900
72901   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72902   {
72903     try {
72904       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
72905     } catch (std::out_of_range& e) {
72906       {
72907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72908       };
72909     } catch (std::exception& e) {
72910       {
72911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72912       };
72913     } catch (Dali::DaliException e) {
72914       {
72915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72916       };
72917     } catch (...) {
72918       {
72919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72920       };
72921     }
72922   }
72923
72924   jresult = result;
72925   return jresult;
72926 }
72927
72928
72929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
72930   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72931   Dali::Actor *arg2 = 0 ;
72932   int arg3 ;
72933   Dali::Vector3 *arg4 = 0 ;
72934   Dali::Actor *arg5 = 0 ;
72935
72936   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72937   arg2 = (Dali::Actor *)jarg2;
72938   if (!arg2) {
72939     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
72940     return ;
72941   }
72942   arg3 = (int)jarg3;
72943   arg4 = (Dali::Vector3 *)jarg4;
72944   if (!arg4) {
72945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72946     return ;
72947   }
72948   arg5 = (Dali::Actor *)jarg5;
72949   if (!arg5) {
72950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
72951     return ;
72952   }
72953   {
72954     try {
72955       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
72956     } catch (std::out_of_range& e) {
72957       {
72958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72959       };
72960     } catch (std::exception& e) {
72961       {
72962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72963       };
72964     } catch (Dali::DaliException e) {
72965       {
72966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72967       };
72968     } catch (...) {
72969       {
72970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72971       };
72972     }
72973   }
72974
72975 }
72976
72977
72978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
72979   void * jresult ;
72980   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
72981   int arg2 ;
72982   float arg3 ;
72983   Dali::Vector3 *arg4 = 0 ;
72984   Dali::Vector3 result;
72985
72986   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
72987   arg2 = (int)jarg2;
72988   arg3 = (float)jarg3;
72989   arg4 = (Dali::Vector3 *)jarg4;
72990   if (!arg4) {
72991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72992     return 0;
72993   }
72994   {
72995     try {
72996       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
72997     } catch (std::out_of_range& e) {
72998       {
72999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73000       };
73001     } catch (std::exception& e) {
73002       {
73003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73004       };
73005     } catch (Dali::DaliException e) {
73006       {
73007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73008       };
73009     } catch (...) {
73010       {
73011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73012       };
73013     }
73014   }
73015
73016   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
73017   return jresult;
73018 }
73019
73020
73021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
73022   void * jresult ;
73023   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
73024   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
73025
73026   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
73027   {
73028     try {
73029       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
73030     } catch (std::out_of_range& e) {
73031       {
73032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73033       };
73034     } catch (std::exception& e) {
73035       {
73036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73037       };
73038     } catch (Dali::DaliException e) {
73039       {
73040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73041       };
73042     } catch (...) {
73043       {
73044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73045       };
73046     }
73047   }
73048
73049   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
73050   return jresult;
73051 }
73052
73053
73054 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
73055   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
73056
73057   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
73058   {
73059     try {
73060       delete arg1;
73061     } catch (std::out_of_range& e) {
73062       {
73063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73064       };
73065     } catch (std::exception& e) {
73066       {
73067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73068       };
73069     } catch (Dali::DaliException e) {
73070       {
73071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73072       };
73073     } catch (...) {
73074       {
73075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73076       };
73077     }
73078   }
73079
73080 }
73081
73082
73083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
73084   unsigned int jresult ;
73085   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
73086   unsigned int result;
73087
73088   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
73089   {
73090     try {
73091       result = (unsigned int)(arg1)->GetNumberOfItems();
73092     } catch (std::out_of_range& e) {
73093       {
73094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73095       };
73096     } catch (std::exception& e) {
73097       {
73098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73099       };
73100     } catch (Dali::DaliException e) {
73101       {
73102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73103       };
73104     } catch (...) {
73105       {
73106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73107       };
73108     }
73109   }
73110
73111   jresult = result;
73112   return jresult;
73113 }
73114
73115
73116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
73117   void * jresult ;
73118   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
73119   unsigned int arg2 ;
73120   Dali::Actor result;
73121
73122   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
73123   arg2 = (unsigned int)jarg2;
73124   {
73125     try {
73126       result = (arg1)->NewItem(arg2);
73127     } catch (std::out_of_range& e) {
73128       {
73129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73130       };
73131     } catch (std::exception& e) {
73132       {
73133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73134       };
73135     } catch (Dali::DaliException e) {
73136       {
73137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73138       };
73139     } catch (...) {
73140       {
73141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73142       };
73143     }
73144   }
73145
73146   jresult = new Dali::Actor((const Dali::Actor &)result);
73147   return jresult;
73148 }
73149
73150
73151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
73152   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
73153   unsigned int arg2 ;
73154   Dali::Actor arg3 ;
73155   Dali::Actor *argp3 ;
73156
73157   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
73158   arg2 = (unsigned int)jarg2;
73159   argp3 = (Dali::Actor *)jarg3;
73160   if (!argp3) {
73161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73162     return ;
73163   }
73164   arg3 = *argp3;
73165   {
73166     try {
73167       (arg1)->ItemReleased(arg2,arg3);
73168     } catch (std::out_of_range& e) {
73169       {
73170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73171       };
73172     } catch (std::exception& e) {
73173       {
73174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73175       };
73176     } catch (Dali::DaliException e) {
73177       {
73178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73179       };
73180     } catch (...) {
73181       {
73182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73183       };
73184     }
73185   }
73186
73187 }
73188
73189
73190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
73191   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
73192   unsigned int arg2 ;
73193   Dali::Actor arg3 ;
73194   Dali::Actor *argp3 ;
73195
73196   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
73197   arg2 = (unsigned int)jarg2;
73198   argp3 = (Dali::Actor *)jarg3;
73199   if (!argp3) {
73200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
73201     return ;
73202   }
73203   arg3 = *argp3;
73204   {
73205     try {
73206       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
73207     } catch (std::out_of_range& e) {
73208       {
73209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73210       };
73211     } catch (std::exception& e) {
73212       {
73213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73214       };
73215     } catch (Dali::DaliException e) {
73216       {
73217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73218       };
73219     } catch (...) {
73220       {
73221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73222       };
73223     }
73224   }
73225
73226 }
73227
73228
73229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
73230   void * jresult ;
73231   Dali::Toolkit::ItemFactory *result = 0 ;
73232
73233   {
73234     try {
73235       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
73236     } catch (std::out_of_range& e) {
73237       {
73238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73239       };
73240     } catch (std::exception& e) {
73241       {
73242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73243       };
73244     } catch (Dali::DaliException e) {
73245       {
73246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73247       };
73248     } catch (...) {
73249       {
73250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73251       };
73252     }
73253   }
73254
73255   jresult = (void *)result;
73256   return jresult;
73257 }
73258
73259
73260 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) {
73261   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
73262   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
73263   if (director) {
73264     director->swig_connect_director(callback0, callback1, callback2);
73265   }
73266 }
73267
73268
73269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
73270   int jresult ;
73271   int result;
73272
73273   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
73274   jresult = (int)result;
73275   return jresult;
73276 }
73277
73278
73279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
73280   int jresult ;
73281   int result;
73282
73283   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
73284   jresult = (int)result;
73285   return jresult;
73286 }
73287
73288
73289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
73290   int jresult ;
73291   int result;
73292
73293   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
73294   jresult = (int)result;
73295   return jresult;
73296 }
73297
73298
73299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
73300   int jresult ;
73301   int result;
73302
73303   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
73304   jresult = (int)result;
73305   return jresult;
73306 }
73307
73308
73309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
73310   int jresult ;
73311   int result;
73312
73313   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
73314   jresult = (int)result;
73315   return jresult;
73316 }
73317
73318
73319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
73320   int jresult ;
73321   int result;
73322
73323   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
73324   jresult = (int)result;
73325   return jresult;
73326 }
73327
73328
73329 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
73330   int jresult ;
73331   int result;
73332
73333   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
73334   jresult = (int)result;
73335   return jresult;
73336 }
73337
73338
73339 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
73340   int jresult ;
73341   int result;
73342
73343   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
73344   jresult = (int)result;
73345   return jresult;
73346 }
73347
73348
73349 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
73350   int jresult ;
73351   int result;
73352
73353   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
73354   jresult = (int)result;
73355   return jresult;
73356 }
73357
73358
73359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
73360   int jresult ;
73361   int result;
73362
73363   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
73364   jresult = (int)result;
73365   return jresult;
73366 }
73367
73368
73369 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
73370   int jresult ;
73371   int result;
73372
73373   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
73374   jresult = (int)result;
73375   return jresult;
73376 }
73377
73378
73379 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
73380   void * jresult ;
73381   Dali::Toolkit::ItemView::Property *result = 0 ;
73382
73383   {
73384     try {
73385       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
73386     } catch (std::out_of_range& e) {
73387       {
73388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73389       };
73390     } catch (std::exception& e) {
73391       {
73392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73393       };
73394     } catch (Dali::DaliException e) {
73395       {
73396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73397       };
73398     } catch (...) {
73399       {
73400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73401       };
73402     }
73403   }
73404
73405   jresult = (void *)result;
73406   return jresult;
73407 }
73408
73409
73410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
73411   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
73412
73413   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
73414   {
73415     try {
73416       delete arg1;
73417     } catch (std::out_of_range& e) {
73418       {
73419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73420       };
73421     } catch (std::exception& e) {
73422       {
73423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73424       };
73425     } catch (Dali::DaliException e) {
73426       {
73427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73428       };
73429     } catch (...) {
73430       {
73431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73432       };
73433     }
73434   }
73435
73436 }
73437
73438
73439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
73440   void * jresult ;
73441   Dali::Toolkit::ItemView *result = 0 ;
73442
73443   {
73444     try {
73445       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
73446     } catch (std::out_of_range& e) {
73447       {
73448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73449       };
73450     } catch (std::exception& e) {
73451       {
73452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73453       };
73454     } catch (Dali::DaliException e) {
73455       {
73456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73457       };
73458     } catch (...) {
73459       {
73460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73461       };
73462     }
73463   }
73464
73465   jresult = (void *)result;
73466   return jresult;
73467 }
73468
73469
73470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
73471   void * jresult ;
73472   Dali::Toolkit::ItemView *arg1 = 0 ;
73473   Dali::Toolkit::ItemView *result = 0 ;
73474
73475   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73476   if (!arg1) {
73477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
73478     return 0;
73479   }
73480   {
73481     try {
73482       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
73483     } catch (std::out_of_range& e) {
73484       {
73485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73486       };
73487     } catch (std::exception& e) {
73488       {
73489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73490       };
73491     } catch (Dali::DaliException e) {
73492       {
73493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73494       };
73495     } catch (...) {
73496       {
73497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73498       };
73499     }
73500   }
73501
73502   jresult = (void *)result;
73503   return jresult;
73504 }
73505
73506
73507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
73508   void * jresult ;
73509   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73510   Dali::Toolkit::ItemView *arg2 = 0 ;
73511   Dali::Toolkit::ItemView *result = 0 ;
73512
73513   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73514   arg2 = (Dali::Toolkit::ItemView *)jarg2;
73515   if (!arg2) {
73516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
73517     return 0;
73518   }
73519   {
73520     try {
73521       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
73522     } catch (std::out_of_range& e) {
73523       {
73524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73525       };
73526     } catch (std::exception& e) {
73527       {
73528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73529       };
73530     } catch (Dali::DaliException e) {
73531       {
73532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73533       };
73534     } catch (...) {
73535       {
73536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73537       };
73538     }
73539   }
73540
73541   jresult = (void *)result;
73542   return jresult;
73543 }
73544
73545
73546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
73547   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73548
73549   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73550   {
73551     try {
73552       delete arg1;
73553     } catch (std::out_of_range& e) {
73554       {
73555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73556       };
73557     } catch (std::exception& e) {
73558       {
73559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73560       };
73561     } catch (Dali::DaliException e) {
73562       {
73563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73564       };
73565     } catch (...) {
73566       {
73567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73568       };
73569     }
73570   }
73571
73572 }
73573
73574
73575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
73576   void * jresult ;
73577   Dali::Toolkit::ItemFactory *arg1 = 0 ;
73578   Dali::Toolkit::ItemView result;
73579
73580   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
73581   if (!arg1) {
73582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
73583     return 0;
73584   }
73585   {
73586     try {
73587       result = Dali::Toolkit::ItemView::New(*arg1);
73588     } catch (std::out_of_range& e) {
73589       {
73590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73591       };
73592     } catch (std::exception& e) {
73593       {
73594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73595       };
73596     } catch (Dali::DaliException e) {
73597       {
73598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73599       };
73600     } catch (...) {
73601       {
73602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73603       };
73604     }
73605   }
73606
73607   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
73608   return jresult;
73609 }
73610
73611
73612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
73613   void * jresult ;
73614   Dali::BaseHandle arg1 ;
73615   Dali::BaseHandle *argp1 ;
73616   Dali::Toolkit::ItemView result;
73617
73618   argp1 = (Dali::BaseHandle *)jarg1;
73619   if (!argp1) {
73620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
73621     return 0;
73622   }
73623   arg1 = *argp1;
73624   {
73625     try {
73626       result = Dali::Toolkit::ItemView::DownCast(arg1);
73627     } catch (std::out_of_range& e) {
73628       {
73629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73630       };
73631     } catch (std::exception& e) {
73632       {
73633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73634       };
73635     } catch (Dali::DaliException e) {
73636       {
73637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73638       };
73639     } catch (...) {
73640       {
73641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73642       };
73643     }
73644   }
73645
73646   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
73647   return jresult;
73648 }
73649
73650
73651 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
73652   unsigned int jresult ;
73653   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73654   unsigned int result;
73655
73656   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73657   {
73658     try {
73659       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
73660     } catch (std::out_of_range& e) {
73661       {
73662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73663       };
73664     } catch (std::exception& e) {
73665       {
73666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73667       };
73668     } catch (Dali::DaliException e) {
73669       {
73670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73671       };
73672     } catch (...) {
73673       {
73674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73675       };
73676     }
73677   }
73678
73679   jresult = result;
73680   return jresult;
73681 }
73682
73683
73684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
73685   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73686   Dali::Toolkit::ItemLayout *arg2 = 0 ;
73687
73688   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73689   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
73690   if (!arg2) {
73691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
73692     return ;
73693   }
73694   {
73695     try {
73696       (arg1)->AddLayout(*arg2);
73697     } catch (std::out_of_range& e) {
73698       {
73699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73700       };
73701     } catch (std::exception& e) {
73702       {
73703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73704       };
73705     } catch (Dali::DaliException e) {
73706       {
73707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73708       };
73709     } catch (...) {
73710       {
73711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73712       };
73713     }
73714   }
73715
73716 }
73717
73718
73719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
73720   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73721   unsigned int arg2 ;
73722
73723   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73724   arg2 = (unsigned int)jarg2;
73725   {
73726     try {
73727       (arg1)->RemoveLayout(arg2);
73728     } catch (std::out_of_range& e) {
73729       {
73730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73731       };
73732     } catch (std::exception& e) {
73733       {
73734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73735       };
73736     } catch (Dali::DaliException e) {
73737       {
73738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73739       };
73740     } catch (...) {
73741       {
73742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73743       };
73744     }
73745   }
73746
73747 }
73748
73749
73750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
73751   void * jresult ;
73752   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73753   unsigned int arg2 ;
73754   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
73755
73756   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73757   arg2 = (unsigned int)jarg2;
73758   {
73759     try {
73760       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
73761     } catch (std::out_of_range& e) {
73762       {
73763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73764       };
73765     } catch (std::exception& e) {
73766       {
73767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73768       };
73769     } catch (Dali::DaliException e) {
73770       {
73771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73772       };
73773     } catch (...) {
73774       {
73775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73776       };
73777     }
73778   }
73779
73780   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
73781   return jresult;
73782 }
73783
73784
73785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
73786   void * jresult ;
73787   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73788   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
73789
73790   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73791   {
73792     try {
73793       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
73794     } catch (std::out_of_range& e) {
73795       {
73796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73797       };
73798     } catch (std::exception& e) {
73799       {
73800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73801       };
73802     } catch (Dali::DaliException e) {
73803       {
73804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73805       };
73806     } catch (...) {
73807       {
73808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73809       };
73810     }
73811   }
73812
73813   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
73814   return jresult;
73815 }
73816
73817
73818 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
73819   float jresult ;
73820   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73821   Dali::Toolkit::ItemId arg2 ;
73822   float result;
73823
73824   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73825   arg2 = (Dali::Toolkit::ItemId)jarg2;
73826   {
73827     try {
73828       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
73829     } catch (std::out_of_range& e) {
73830       {
73831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73832       };
73833     } catch (std::exception& e) {
73834       {
73835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73836       };
73837     } catch (Dali::DaliException e) {
73838       {
73839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73840       };
73841     } catch (...) {
73842       {
73843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73844       };
73845     }
73846   }
73847
73848   jresult = result;
73849   return jresult;
73850 }
73851
73852
73853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
73854   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73855   unsigned int arg2 ;
73856   Dali::Vector3 arg3 ;
73857   float arg4 ;
73858   Dali::Vector3 *argp3 ;
73859
73860   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73861   arg2 = (unsigned int)jarg2;
73862   argp3 = (Dali::Vector3 *)jarg3;
73863   if (!argp3) {
73864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
73865     return ;
73866   }
73867   arg3 = *argp3;
73868   arg4 = (float)jarg4;
73869   {
73870     try {
73871       (arg1)->ActivateLayout(arg2,arg3,arg4);
73872     } catch (std::out_of_range& e) {
73873       {
73874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73875       };
73876     } catch (std::exception& e) {
73877       {
73878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73879       };
73880     } catch (Dali::DaliException e) {
73881       {
73882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73883       };
73884     } catch (...) {
73885       {
73886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73887       };
73888     }
73889   }
73890
73891 }
73892
73893
73894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
73895   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73896
73897   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73898   {
73899     try {
73900       (arg1)->DeactivateCurrentLayout();
73901     } catch (std::out_of_range& e) {
73902       {
73903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73904       };
73905     } catch (std::exception& e) {
73906       {
73907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73908       };
73909     } catch (Dali::DaliException e) {
73910       {
73911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73912       };
73913     } catch (...) {
73914       {
73915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73916       };
73917     }
73918   }
73919
73920 }
73921
73922
73923 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
73924   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73925   float arg2 ;
73926
73927   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73928   arg2 = (float)jarg2;
73929   {
73930     try {
73931       (arg1)->SetMinimumSwipeSpeed(arg2);
73932     } catch (std::out_of_range& e) {
73933       {
73934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73935       };
73936     } catch (std::exception& e) {
73937       {
73938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73939       };
73940     } catch (Dali::DaliException e) {
73941       {
73942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73943       };
73944     } catch (...) {
73945       {
73946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73947       };
73948     }
73949   }
73950
73951 }
73952
73953
73954 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
73955   float jresult ;
73956   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73957   float result;
73958
73959   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73960   {
73961     try {
73962       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
73963     } catch (std::out_of_range& e) {
73964       {
73965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73966       };
73967     } catch (std::exception& e) {
73968       {
73969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73970       };
73971     } catch (Dali::DaliException e) {
73972       {
73973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73974       };
73975     } catch (...) {
73976       {
73977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73978       };
73979     }
73980   }
73981
73982   jresult = result;
73983   return jresult;
73984 }
73985
73986
73987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
73988   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
73989   float arg2 ;
73990
73991   arg1 = (Dali::Toolkit::ItemView *)jarg1;
73992   arg2 = (float)jarg2;
73993   {
73994     try {
73995       (arg1)->SetMinimumSwipeDistance(arg2);
73996     } catch (std::out_of_range& e) {
73997       {
73998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73999       };
74000     } catch (std::exception& e) {
74001       {
74002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74003       };
74004     } catch (Dali::DaliException e) {
74005       {
74006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74007       };
74008     } catch (...) {
74009       {
74010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74011       };
74012     }
74013   }
74014
74015 }
74016
74017
74018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
74019   float jresult ;
74020   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74021   float result;
74022
74023   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74024   {
74025     try {
74026       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
74027     } catch (std::out_of_range& e) {
74028       {
74029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74030       };
74031     } catch (std::exception& e) {
74032       {
74033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74034       };
74035     } catch (Dali::DaliException e) {
74036       {
74037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74038       };
74039     } catch (...) {
74040       {
74041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74042       };
74043     }
74044   }
74045
74046   jresult = result;
74047   return jresult;
74048 }
74049
74050
74051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
74052   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74053   float arg2 ;
74054
74055   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74056   arg2 = (float)jarg2;
74057   {
74058     try {
74059       (arg1)->SetWheelScrollDistanceStep(arg2);
74060     } catch (std::out_of_range& e) {
74061       {
74062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74063       };
74064     } catch (std::exception& e) {
74065       {
74066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74067       };
74068     } catch (Dali::DaliException e) {
74069       {
74070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74071       };
74072     } catch (...) {
74073       {
74074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74075       };
74076     }
74077   }
74078
74079 }
74080
74081
74082 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
74083   float jresult ;
74084   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74085   float result;
74086
74087   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74088   {
74089     try {
74090       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
74091     } catch (std::out_of_range& e) {
74092       {
74093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74094       };
74095     } catch (std::exception& e) {
74096       {
74097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74098       };
74099     } catch (Dali::DaliException e) {
74100       {
74101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74102       };
74103     } catch (...) {
74104       {
74105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74106       };
74107     }
74108   }
74109
74110   jresult = result;
74111   return jresult;
74112 }
74113
74114
74115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
74116   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74117   bool arg2 ;
74118
74119   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74120   arg2 = jarg2 ? true : false;
74121   {
74122     try {
74123       (arg1)->SetAnchoring(arg2);
74124     } catch (std::out_of_range& e) {
74125       {
74126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74127       };
74128     } catch (std::exception& e) {
74129       {
74130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74131       };
74132     } catch (Dali::DaliException e) {
74133       {
74134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74135       };
74136     } catch (...) {
74137       {
74138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74139       };
74140     }
74141   }
74142
74143 }
74144
74145 //// ========================= end of part 3 =============================
74146
74147 //// ========================== start part 4 ===============================
74148
74149
74150 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
74151   unsigned int jresult ;
74152   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74153   bool result;
74154
74155   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74156   {
74157     try {
74158       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
74159     } catch (std::out_of_range& e) {
74160       {
74161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74162       };
74163     } catch (std::exception& e) {
74164       {
74165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74166       };
74167     } catch (Dali::DaliException e) {
74168       {
74169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74170       };
74171     } catch (...) {
74172       {
74173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74174       };
74175     }
74176   }
74177
74178   jresult = result;
74179   return jresult;
74180 }
74181
74182
74183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
74184   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74185   float arg2 ;
74186
74187   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74188   arg2 = (float)jarg2;
74189   {
74190     try {
74191       (arg1)->SetAnchoringDuration(arg2);
74192     } catch (std::out_of_range& e) {
74193       {
74194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74195       };
74196     } catch (std::exception& e) {
74197       {
74198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74199       };
74200     } catch (Dali::DaliException e) {
74201       {
74202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74203       };
74204     } catch (...) {
74205       {
74206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74207       };
74208     }
74209   }
74210
74211 }
74212
74213
74214 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
74215   float jresult ;
74216   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74217   float result;
74218
74219   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74220   {
74221     try {
74222       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
74223     } catch (std::out_of_range& e) {
74224       {
74225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74226       };
74227     } catch (std::exception& e) {
74228       {
74229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74230       };
74231     } catch (Dali::DaliException e) {
74232       {
74233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74234       };
74235     } catch (...) {
74236       {
74237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74238       };
74239     }
74240   }
74241
74242   jresult = result;
74243   return jresult;
74244 }
74245
74246
74247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
74248   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74249   Dali::Toolkit::ItemId arg2 ;
74250   float arg3 ;
74251
74252   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74253   arg2 = (Dali::Toolkit::ItemId)jarg2;
74254   arg3 = (float)jarg3;
74255   {
74256     try {
74257       (arg1)->ScrollToItem(arg2,arg3);
74258     } catch (std::out_of_range& e) {
74259       {
74260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74261       };
74262     } catch (std::exception& e) {
74263       {
74264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74265       };
74266     } catch (Dali::DaliException e) {
74267       {
74268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74269       };
74270     } catch (...) {
74271       {
74272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74273       };
74274     }
74275   }
74276
74277 }
74278
74279
74280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
74281   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74282   float arg2 ;
74283
74284   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74285   arg2 = (float)jarg2;
74286   {
74287     try {
74288       (arg1)->SetRefreshInterval(arg2);
74289     } catch (std::out_of_range& e) {
74290       {
74291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74292       };
74293     } catch (std::exception& e) {
74294       {
74295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74296       };
74297     } catch (Dali::DaliException e) {
74298       {
74299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74300       };
74301     } catch (...) {
74302       {
74303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74304       };
74305     }
74306   }
74307
74308 }
74309
74310
74311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
74312   float jresult ;
74313   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74314   float result;
74315
74316   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74317   {
74318     try {
74319       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
74320     } catch (std::out_of_range& e) {
74321       {
74322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74323       };
74324     } catch (std::exception& e) {
74325       {
74326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74327       };
74328     } catch (Dali::DaliException e) {
74329       {
74330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74331       };
74332     } catch (...) {
74333       {
74334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74335       };
74336     }
74337   }
74338
74339   jresult = result;
74340   return jresult;
74341 }
74342
74343
74344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
74345   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74346
74347   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74348   {
74349     try {
74350       (arg1)->Refresh();
74351     } catch (std::out_of_range& e) {
74352       {
74353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74354       };
74355     } catch (std::exception& e) {
74356       {
74357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74358       };
74359     } catch (Dali::DaliException e) {
74360       {
74361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74362       };
74363     } catch (...) {
74364       {
74365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74366       };
74367     }
74368   }
74369
74370 }
74371
74372
74373 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
74374   void * jresult ;
74375   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74376   Dali::Toolkit::ItemId arg2 ;
74377   Dali::Actor result;
74378
74379   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74380   arg2 = (Dali::Toolkit::ItemId)jarg2;
74381   {
74382     try {
74383       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
74384     } catch (std::out_of_range& e) {
74385       {
74386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74387       };
74388     } catch (std::exception& e) {
74389       {
74390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74391       };
74392     } catch (Dali::DaliException e) {
74393       {
74394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74395       };
74396     } catch (...) {
74397       {
74398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74399       };
74400     }
74401   }
74402
74403   jresult = new Dali::Actor((const Dali::Actor &)result);
74404   return jresult;
74405 }
74406
74407
74408 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
74409   unsigned int jresult ;
74410   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74411   Dali::Actor arg2 ;
74412   Dali::Actor *argp2 ;
74413   Dali::Toolkit::ItemId result;
74414
74415   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74416   argp2 = (Dali::Actor *)jarg2;
74417   if (!argp2) {
74418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
74419     return 0;
74420   }
74421   arg2 = *argp2;
74422   {
74423     try {
74424       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
74425     } catch (std::out_of_range& e) {
74426       {
74427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74428       };
74429     } catch (std::exception& e) {
74430       {
74431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74432       };
74433     } catch (Dali::DaliException e) {
74434       {
74435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74436       };
74437     } catch (...) {
74438       {
74439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74440       };
74441     }
74442   }
74443
74444   jresult = result;
74445   return jresult;
74446 }
74447
74448
74449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
74450   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74451   Dali::Toolkit::Item arg2 ;
74452   float arg3 ;
74453   Dali::Toolkit::Item *argp2 ;
74454
74455   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74456   argp2 = (Dali::Toolkit::Item *)jarg2;
74457   if (!argp2) {
74458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
74459     return ;
74460   }
74461   arg2 = *argp2;
74462   arg3 = (float)jarg3;
74463   {
74464     try {
74465       (arg1)->InsertItem(arg2,arg3);
74466     } catch (std::out_of_range& e) {
74467       {
74468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74469       };
74470     } catch (std::exception& e) {
74471       {
74472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74473       };
74474     } catch (Dali::DaliException e) {
74475       {
74476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74477       };
74478     } catch (...) {
74479       {
74480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74481       };
74482     }
74483   }
74484
74485 }
74486
74487
74488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
74489   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74490   Dali::Toolkit::ItemContainer *arg2 = 0 ;
74491   float arg3 ;
74492
74493   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74494   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
74495   if (!arg2) {
74496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
74497     return ;
74498   }
74499   arg3 = (float)jarg3;
74500   {
74501     try {
74502       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
74503     } catch (std::out_of_range& e) {
74504       {
74505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74506       };
74507     } catch (std::exception& e) {
74508       {
74509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74510       };
74511     } catch (Dali::DaliException e) {
74512       {
74513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74514       };
74515     } catch (...) {
74516       {
74517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74518       };
74519     }
74520   }
74521
74522 }
74523
74524
74525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
74526   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74527   Dali::Toolkit::ItemId arg2 ;
74528   float arg3 ;
74529
74530   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74531   arg2 = (Dali::Toolkit::ItemId)jarg2;
74532   arg3 = (float)jarg3;
74533   {
74534     try {
74535       (arg1)->RemoveItem(arg2,arg3);
74536     } catch (std::out_of_range& e) {
74537       {
74538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74539       };
74540     } catch (std::exception& e) {
74541       {
74542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74543       };
74544     } catch (Dali::DaliException e) {
74545       {
74546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74547       };
74548     } catch (...) {
74549       {
74550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74551       };
74552     }
74553   }
74554
74555 }
74556
74557
74558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
74559   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74560   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
74561   float arg3 ;
74562
74563   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74564   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
74565   if (!arg2) {
74566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
74567     return ;
74568   }
74569   arg3 = (float)jarg3;
74570   {
74571     try {
74572       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
74573     } catch (std::out_of_range& e) {
74574       {
74575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74576       };
74577     } catch (std::exception& e) {
74578       {
74579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74580       };
74581     } catch (Dali::DaliException e) {
74582       {
74583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74584       };
74585     } catch (...) {
74586       {
74587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74588       };
74589     }
74590   }
74591
74592 }
74593
74594
74595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
74596   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74597   Dali::Toolkit::Item arg2 ;
74598   float arg3 ;
74599   Dali::Toolkit::Item *argp2 ;
74600
74601   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74602   argp2 = (Dali::Toolkit::Item *)jarg2;
74603   if (!argp2) {
74604     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
74605     return ;
74606   }
74607   arg2 = *argp2;
74608   arg3 = (float)jarg3;
74609   {
74610     try {
74611       (arg1)->ReplaceItem(arg2,arg3);
74612     } catch (std::out_of_range& e) {
74613       {
74614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74615       };
74616     } catch (std::exception& e) {
74617       {
74618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74619       };
74620     } catch (Dali::DaliException e) {
74621       {
74622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74623       };
74624     } catch (...) {
74625       {
74626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74627       };
74628     }
74629   }
74630
74631 }
74632
74633
74634 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
74635   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74636   Dali::Toolkit::ItemContainer *arg2 = 0 ;
74637   float arg3 ;
74638
74639   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74640   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
74641   if (!arg2) {
74642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
74643     return ;
74644   }
74645   arg3 = (float)jarg3;
74646   {
74647     try {
74648       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
74649     } catch (std::out_of_range& e) {
74650       {
74651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74652       };
74653     } catch (std::exception& e) {
74654       {
74655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74656       };
74657     } catch (Dali::DaliException e) {
74658       {
74659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74660       };
74661     } catch (...) {
74662       {
74663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74664       };
74665     }
74666   }
74667
74668 }
74669
74670
74671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
74672   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74673   Dali::Vector3 *arg2 = 0 ;
74674
74675   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74676   arg2 = (Dali::Vector3 *)jarg2;
74677   if (!arg2) {
74678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74679     return ;
74680   }
74681   {
74682     try {
74683       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
74684     } catch (std::out_of_range& e) {
74685       {
74686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74687       };
74688     } catch (std::exception& e) {
74689       {
74690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74691       };
74692     } catch (Dali::DaliException e) {
74693       {
74694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74695       };
74696     } catch (...) {
74697       {
74698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74699       };
74700     }
74701   }
74702
74703 }
74704
74705
74706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
74707   void * jresult ;
74708   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74709   Dali::Vector3 result;
74710
74711   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74712   {
74713     try {
74714       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
74715     } catch (std::out_of_range& e) {
74716       {
74717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74718       };
74719     } catch (std::exception& e) {
74720       {
74721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74722       };
74723     } catch (Dali::DaliException e) {
74724       {
74725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74726       };
74727     } catch (...) {
74728       {
74729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74730       };
74731     }
74732   }
74733
74734   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74735   return jresult;
74736 }
74737
74738
74739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
74740   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74741   Dali::Vector3 *arg2 = 0 ;
74742
74743   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74744   arg2 = (Dali::Vector3 *)jarg2;
74745   if (!arg2) {
74746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
74747     return ;
74748   }
74749   {
74750     try {
74751       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
74752     } catch (std::out_of_range& e) {
74753       {
74754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74755       };
74756     } catch (std::exception& e) {
74757       {
74758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74759       };
74760     } catch (Dali::DaliException e) {
74761       {
74762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74763       };
74764     } catch (...) {
74765       {
74766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74767       };
74768     }
74769   }
74770
74771 }
74772
74773
74774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
74775   void * jresult ;
74776   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74777   Dali::Vector3 result;
74778
74779   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74780   {
74781     try {
74782       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
74783     } catch (std::out_of_range& e) {
74784       {
74785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74786       };
74787     } catch (std::exception& e) {
74788       {
74789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74790       };
74791     } catch (Dali::DaliException e) {
74792       {
74793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74794       };
74795     } catch (...) {
74796       {
74797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74798       };
74799     }
74800   }
74801
74802   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
74803   return jresult;
74804 }
74805
74806
74807 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
74808   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74809   Dali::Toolkit::ItemRange *arg2 = 0 ;
74810
74811   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74812   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
74813   if (!arg2) {
74814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
74815     return ;
74816   }
74817   {
74818     try {
74819       (arg1)->GetItemsRange(*arg2);
74820     } catch (std::out_of_range& e) {
74821       {
74822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74823       };
74824     } catch (std::exception& e) {
74825       {
74826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74827       };
74828     } catch (Dali::DaliException e) {
74829       {
74830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74831       };
74832     } catch (...) {
74833       {
74834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74835       };
74836     }
74837   }
74838
74839 }
74840
74841
74842 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
74843   void * jresult ;
74844   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
74845   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
74846
74847   arg1 = (Dali::Toolkit::ItemView *)jarg1;
74848   {
74849     try {
74850       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
74851     } catch (std::out_of_range& e) {
74852       {
74853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74854       };
74855     } catch (std::exception& e) {
74856       {
74857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74858       };
74859     } catch (Dali::DaliException e) {
74860       {
74861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74862       };
74863     } catch (...) {
74864       {
74865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74866       };
74867     }
74868   }
74869
74870   jresult = (void *)result;
74871   return jresult;
74872 }
74873
74874
74875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
74876   Dali::Vector3 *arg1 = 0 ;
74877   PropertyInputContainer *arg2 = 0 ;
74878
74879   arg1 = (Dali::Vector3 *)jarg1;
74880   if (!arg1) {
74881     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74882     return ;
74883   }
74884   arg2 = (PropertyInputContainer *)jarg2;
74885   if (!arg2) {
74886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
74887     return ;
74888   }
74889   {
74890     try {
74891       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
74892     } catch (std::out_of_range& e) {
74893       {
74894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74895       };
74896     } catch (std::exception& e) {
74897       {
74898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74899       };
74900     } catch (Dali::DaliException e) {
74901       {
74902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74903       };
74904     } catch (...) {
74905       {
74906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74907       };
74908     }
74909   }
74910
74911 }
74912
74913
74914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
74915   Dali::Vector3 *arg1 = 0 ;
74916   PropertyInputContainer *arg2 = 0 ;
74917
74918   arg1 = (Dali::Vector3 *)jarg1;
74919   if (!arg1) {
74920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
74921     return ;
74922   }
74923   arg2 = (PropertyInputContainer *)jarg2;
74924   if (!arg2) {
74925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
74926     return ;
74927   }
74928   {
74929     try {
74930       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
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 (Dali::DaliException e) {
74940       {
74941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74942       };
74943     } catch (...) {
74944       {
74945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74946       };
74947     }
74948   }
74949
74950 }
74951
74952
74953 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
74954   void * jresult ;
74955   Dali::Toolkit::ScrollViewEffect *result = 0 ;
74956
74957   {
74958     try {
74959       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
74960     } catch (std::out_of_range& e) {
74961       {
74962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74963       };
74964     } catch (std::exception& e) {
74965       {
74966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74967       };
74968     } catch (Dali::DaliException e) {
74969       {
74970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74971       };
74972     } catch (...) {
74973       {
74974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74975       };
74976     }
74977   }
74978
74979   jresult = (void *)result;
74980   return jresult;
74981 }
74982
74983
74984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
74985   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
74986
74987   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
74988   {
74989     try {
74990       delete arg1;
74991     } catch (std::out_of_range& e) {
74992       {
74993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74994       };
74995     } catch (std::exception& e) {
74996       {
74997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74998       };
74999     } catch (Dali::DaliException e) {
75000       {
75001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75002       };
75003     } catch (...) {
75004       {
75005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75006       };
75007     }
75008   }
75009
75010 }
75011
75012
75013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
75014   void * jresult ;
75015   Dali::Path arg1 ;
75016   Dali::Vector3 *arg2 = 0 ;
75017   Dali::Property::Index arg3 ;
75018   Dali::Vector3 *arg4 = 0 ;
75019   unsigned int arg5 ;
75020   Dali::Path *argp1 ;
75021   Dali::Toolkit::ScrollViewPagePathEffect result;
75022
75023   argp1 = (Dali::Path *)jarg1;
75024   if (!argp1) {
75025     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
75026     return 0;
75027   }
75028   arg1 = *argp1;
75029   arg2 = (Dali::Vector3 *)jarg2;
75030   if (!arg2) {
75031     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75032     return 0;
75033   }
75034   arg3 = (Dali::Property::Index)jarg3;
75035   arg4 = (Dali::Vector3 *)jarg4;
75036   if (!arg4) {
75037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
75038     return 0;
75039   }
75040   arg5 = (unsigned int)jarg5;
75041   {
75042     try {
75043       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
75044     } catch (std::out_of_range& e) {
75045       {
75046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75047       };
75048     } catch (std::exception& e) {
75049       {
75050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75051       };
75052     } catch (Dali::DaliException e) {
75053       {
75054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75055       };
75056     } catch (...) {
75057       {
75058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75059       };
75060     }
75061   }
75062
75063   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
75064   return jresult;
75065 }
75066
75067
75068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
75069   void * jresult ;
75070   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
75071
75072   {
75073     try {
75074       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
75075     } catch (std::out_of_range& e) {
75076       {
75077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75078       };
75079     } catch (std::exception& e) {
75080       {
75081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75082       };
75083     } catch (Dali::DaliException e) {
75084       {
75085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75086       };
75087     } catch (...) {
75088       {
75089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75090       };
75091     }
75092   }
75093
75094   jresult = (void *)result;
75095   return jresult;
75096 }
75097
75098
75099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
75100   void * jresult ;
75101   Dali::BaseHandle arg1 ;
75102   Dali::BaseHandle *argp1 ;
75103   Dali::Toolkit::ScrollViewPagePathEffect result;
75104
75105   argp1 = (Dali::BaseHandle *)jarg1;
75106   if (!argp1) {
75107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75108     return 0;
75109   }
75110   arg1 = *argp1;
75111   {
75112     try {
75113       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
75114     } catch (std::out_of_range& e) {
75115       {
75116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75117       };
75118     } catch (std::exception& e) {
75119       {
75120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75121       };
75122     } catch (Dali::DaliException e) {
75123       {
75124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75125       };
75126     } catch (...) {
75127       {
75128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75129       };
75130     }
75131   }
75132
75133   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
75134   return jresult;
75135 }
75136
75137
75138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
75139   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
75140   Dali::Actor arg2 ;
75141   unsigned int arg3 ;
75142   Dali::Actor *argp2 ;
75143
75144   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
75145   argp2 = (Dali::Actor *)jarg2;
75146   if (!argp2) {
75147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
75148     return ;
75149   }
75150   arg2 = *argp2;
75151   arg3 = (unsigned int)jarg3;
75152   {
75153     try {
75154       (arg1)->ApplyToPage(arg2,arg3);
75155     } catch (std::out_of_range& e) {
75156       {
75157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75158       };
75159     } catch (std::exception& e) {
75160       {
75161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75162       };
75163     } catch (Dali::DaliException e) {
75164       {
75165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75166       };
75167     } catch (...) {
75168       {
75169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75170       };
75171     }
75172   }
75173
75174 }
75175
75176
75177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
75178   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
75179
75180   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
75181   {
75182     try {
75183       delete arg1;
75184     } catch (std::out_of_range& e) {
75185       {
75186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75187       };
75188     } catch (std::exception& e) {
75189       {
75190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75191       };
75192     } catch (Dali::DaliException e) {
75193       {
75194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75195       };
75196     } catch (...) {
75197       {
75198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75199       };
75200     }
75201   }
75202
75203 }
75204
75205
75206 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
75207   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
75208   Dali::Toolkit::ClampState arg2 ;
75209
75210   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
75211   arg2 = (Dali::Toolkit::ClampState)jarg2;
75212   if (arg1) (arg1)->x = arg2;
75213 }
75214
75215
75216 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
75217   int jresult ;
75218   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
75219   Dali::Toolkit::ClampState result;
75220
75221   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
75222   result = (Dali::Toolkit::ClampState) ((arg1)->x);
75223   jresult = (int)result;
75224   return jresult;
75225 }
75226
75227
75228 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
75229   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
75230   Dali::Toolkit::ClampState arg2 ;
75231
75232   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
75233   arg2 = (Dali::Toolkit::ClampState)jarg2;
75234   if (arg1) (arg1)->y = arg2;
75235 }
75236
75237
75238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
75239   int jresult ;
75240   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
75241   Dali::Toolkit::ClampState result;
75242
75243   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
75244   result = (Dali::Toolkit::ClampState) ((arg1)->y);
75245   jresult = (int)result;
75246   return jresult;
75247 }
75248
75249
75250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
75251   void * jresult ;
75252   Dali::Toolkit::ClampState2D *result = 0 ;
75253
75254   {
75255     try {
75256       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
75257     } catch (std::out_of_range& e) {
75258       {
75259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75260       };
75261     } catch (std::exception& e) {
75262       {
75263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75264       };
75265     } catch (Dali::DaliException e) {
75266       {
75267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75268       };
75269     } catch (...) {
75270       {
75271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75272       };
75273     }
75274   }
75275
75276   jresult = (void *)result;
75277   return jresult;
75278 }
75279
75280
75281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
75282   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
75283
75284   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
75285   {
75286     try {
75287       delete arg1;
75288     } catch (std::out_of_range& e) {
75289       {
75290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75291       };
75292     } catch (std::exception& e) {
75293       {
75294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75295       };
75296     } catch (Dali::DaliException e) {
75297       {
75298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75299       };
75300     } catch (...) {
75301       {
75302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75303       };
75304     }
75305   }
75306
75307 }
75308
75309
75310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
75311   void * jresult ;
75312   float arg1 ;
75313   float arg2 ;
75314   bool arg3 ;
75315   Dali::Toolkit::RulerDomain *result = 0 ;
75316
75317   arg1 = (float)jarg1;
75318   arg2 = (float)jarg2;
75319   arg3 = jarg3 ? true : false;
75320   {
75321     try {
75322       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
75323     } catch (std::out_of_range& e) {
75324       {
75325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75326       };
75327     } catch (std::exception& e) {
75328       {
75329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75330       };
75331     } catch (Dali::DaliException e) {
75332       {
75333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75334       };
75335     } catch (...) {
75336       {
75337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75338       };
75339     }
75340   }
75341
75342   jresult = (void *)result;
75343   return jresult;
75344 }
75345
75346
75347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
75348   void * jresult ;
75349   float arg1 ;
75350   float arg2 ;
75351   Dali::Toolkit::RulerDomain *result = 0 ;
75352
75353   arg1 = (float)jarg1;
75354   arg2 = (float)jarg2;
75355   {
75356     try {
75357       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
75358     } catch (std::out_of_range& e) {
75359       {
75360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75361       };
75362     } catch (std::exception& e) {
75363       {
75364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75365       };
75366     } catch (Dali::DaliException e) {
75367       {
75368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75369       };
75370     } catch (...) {
75371       {
75372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75373       };
75374     }
75375   }
75376
75377   jresult = (void *)result;
75378   return jresult;
75379 }
75380
75381
75382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
75383   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75384   float arg2 ;
75385
75386   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75387   arg2 = (float)jarg2;
75388   if (arg1) (arg1)->min = arg2;
75389 }
75390
75391
75392 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
75393   float jresult ;
75394   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75395   float result;
75396
75397   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75398   result = (float) ((arg1)->min);
75399   jresult = result;
75400   return jresult;
75401 }
75402
75403
75404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
75405   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75406   float arg2 ;
75407
75408   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75409   arg2 = (float)jarg2;
75410   if (arg1) (arg1)->max = arg2;
75411 }
75412
75413
75414 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
75415   float jresult ;
75416   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75417   float result;
75418
75419   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75420   result = (float) ((arg1)->max);
75421   jresult = result;
75422   return jresult;
75423 }
75424
75425
75426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
75427   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75428   bool arg2 ;
75429
75430   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75431   arg2 = jarg2 ? true : false;
75432   if (arg1) (arg1)->enabled = arg2;
75433 }
75434
75435
75436 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
75437   unsigned int jresult ;
75438   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75439   bool result;
75440
75441   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75442   result = (bool) ((arg1)->enabled);
75443   jresult = result;
75444   return jresult;
75445 }
75446
75447
75448 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
75449   float jresult ;
75450   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75451   float arg2 ;
75452   float arg3 ;
75453   float arg4 ;
75454   float result;
75455
75456   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75457   arg2 = (float)jarg2;
75458   arg3 = (float)jarg3;
75459   arg4 = (float)jarg4;
75460   {
75461     try {
75462       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
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 (Dali::DaliException e) {
75472       {
75473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75474       };
75475     } catch (...) {
75476       {
75477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75478       };
75479     }
75480   }
75481
75482   jresult = result;
75483   return jresult;
75484 }
75485
75486
75487 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
75488   float jresult ;
75489   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75490   float arg2 ;
75491   float arg3 ;
75492   float result;
75493
75494   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75495   arg2 = (float)jarg2;
75496   arg3 = (float)jarg3;
75497   {
75498     try {
75499       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
75500     } catch (std::out_of_range& e) {
75501       {
75502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75503       };
75504     } catch (std::exception& e) {
75505       {
75506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75507       };
75508     } catch (Dali::DaliException e) {
75509       {
75510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75511       };
75512     } catch (...) {
75513       {
75514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75515       };
75516     }
75517   }
75518
75519   jresult = result;
75520   return jresult;
75521 }
75522
75523
75524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
75525   float jresult ;
75526   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75527   float arg2 ;
75528   float result;
75529
75530   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75531   arg2 = (float)jarg2;
75532   {
75533     try {
75534       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
75535     } catch (std::out_of_range& e) {
75536       {
75537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75538       };
75539     } catch (std::exception& e) {
75540       {
75541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75542       };
75543     } catch (Dali::DaliException e) {
75544       {
75545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75546       };
75547     } catch (...) {
75548       {
75549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75550       };
75551     }
75552   }
75553
75554   jresult = result;
75555   return jresult;
75556 }
75557
75558
75559 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
75560   float jresult ;
75561   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75562   float arg2 ;
75563   float arg3 ;
75564   float arg4 ;
75565   Dali::Toolkit::ClampState *arg5 = 0 ;
75566   float result;
75567
75568   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75569   arg2 = (float)jarg2;
75570   arg3 = (float)jarg3;
75571   arg4 = (float)jarg4;
75572   arg5 = (Dali::Toolkit::ClampState *)jarg5;
75573   if (!arg5) {
75574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
75575     return 0;
75576   }
75577   {
75578     try {
75579       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
75580     } catch (std::out_of_range& e) {
75581       {
75582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75583       };
75584     } catch (std::exception& e) {
75585       {
75586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75587       };
75588     } catch (Dali::DaliException e) {
75589       {
75590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75591       };
75592     } catch (...) {
75593       {
75594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75595       };
75596     }
75597   }
75598
75599   jresult = result;
75600   return jresult;
75601 }
75602
75603
75604 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
75605   float jresult ;
75606   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75607   float result;
75608
75609   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75610   {
75611     try {
75612       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
75613     } catch (std::out_of_range& e) {
75614       {
75615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75616       };
75617     } catch (std::exception& e) {
75618       {
75619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75620       };
75621     } catch (Dali::DaliException e) {
75622       {
75623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75624       };
75625     } catch (...) {
75626       {
75627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75628       };
75629     }
75630   }
75631
75632   jresult = result;
75633   return jresult;
75634 }
75635
75636
75637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
75638   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
75639
75640   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
75641   {
75642     try {
75643       delete arg1;
75644     } catch (std::out_of_range& e) {
75645       {
75646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75647       };
75648     } catch (std::exception& e) {
75649       {
75650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75651       };
75652     } catch (Dali::DaliException e) {
75653       {
75654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75655       };
75656     } catch (...) {
75657       {
75658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75659       };
75660     }
75661   }
75662
75663 }
75664
75665
75666 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
75667   float jresult ;
75668   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75669   float arg2 ;
75670   float arg3 ;
75671   float result;
75672
75673   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75674   arg2 = (float)jarg2;
75675   arg3 = (float)jarg3;
75676   {
75677     try {
75678       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
75679     } catch (std::out_of_range& e) {
75680       {
75681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75682       };
75683     } catch (std::exception& e) {
75684       {
75685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75686       };
75687     } catch (Dali::DaliException e) {
75688       {
75689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75690       };
75691     } catch (...) {
75692       {
75693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75694       };
75695     }
75696   }
75697
75698   jresult = result;
75699   return jresult;
75700 }
75701
75702
75703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
75704   float jresult ;
75705   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75706   float arg2 ;
75707   float result;
75708
75709   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75710   arg2 = (float)jarg2;
75711   {
75712     try {
75713       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
75714     } catch (std::out_of_range& e) {
75715       {
75716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75717       };
75718     } catch (std::exception& e) {
75719       {
75720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75721       };
75722     } catch (Dali::DaliException e) {
75723       {
75724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75725       };
75726     } catch (...) {
75727       {
75728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75729       };
75730     }
75731   }
75732
75733   jresult = result;
75734   return jresult;
75735 }
75736
75737
75738 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
75739   float jresult ;
75740   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75741   unsigned int arg2 ;
75742   unsigned int *arg3 = 0 ;
75743   bool arg4 ;
75744   float result;
75745
75746   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75747   arg2 = (unsigned int)jarg2;
75748   arg3 = (unsigned int *)jarg3;
75749   arg4 = jarg4 ? true : false;
75750   {
75751     try {
75752       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
75753     } catch (std::out_of_range& e) {
75754       {
75755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75756       };
75757     } catch (std::exception& e) {
75758       {
75759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75760       };
75761     } catch (Dali::DaliException e) {
75762       {
75763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75764       };
75765     } catch (...) {
75766       {
75767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75768       };
75769     }
75770   }
75771
75772   jresult = result;
75773   return jresult;
75774 }
75775
75776
75777 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
75778   unsigned int jresult ;
75779   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75780   float arg2 ;
75781   bool arg3 ;
75782   unsigned int result;
75783
75784   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75785   arg2 = (float)jarg2;
75786   arg3 = jarg3 ? true : false;
75787   {
75788     try {
75789       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
75790     } catch (std::out_of_range& e) {
75791       {
75792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75793       };
75794     } catch (std::exception& e) {
75795       {
75796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75797       };
75798     } catch (Dali::DaliException e) {
75799       {
75800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75801       };
75802     } catch (...) {
75803       {
75804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75805       };
75806     }
75807   }
75808
75809   jresult = result;
75810   return jresult;
75811 }
75812
75813
75814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
75815   unsigned int jresult ;
75816   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75817   unsigned int result;
75818
75819   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75820   {
75821     try {
75822       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
75823     } catch (std::out_of_range& e) {
75824       {
75825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75826       };
75827     } catch (std::exception& e) {
75828       {
75829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75830       };
75831     } catch (Dali::DaliException e) {
75832       {
75833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75834       };
75835     } catch (...) {
75836       {
75837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75838       };
75839     }
75840   }
75841
75842   jresult = result;
75843   return jresult;
75844 }
75845
75846
75847 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
75848   int jresult ;
75849   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75850   Dali::Toolkit::Ruler::RulerType result;
75851
75852   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75853   {
75854     try {
75855       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
75856     } catch (std::out_of_range& e) {
75857       {
75858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75859       };
75860     } catch (std::exception& e) {
75861       {
75862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75863       };
75864     } catch (Dali::DaliException e) {
75865       {
75866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75867       };
75868     } catch (...) {
75869       {
75870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75871       };
75872     }
75873   }
75874
75875   jresult = (int)result;
75876   return jresult;
75877 }
75878
75879
75880 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
75881   unsigned int jresult ;
75882   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75883   bool result;
75884
75885   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75886   {
75887     try {
75888       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
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 (Dali::DaliException e) {
75898       {
75899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75900       };
75901     } catch (...) {
75902       {
75903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75904       };
75905     }
75906   }
75907
75908   jresult = result;
75909   return jresult;
75910 }
75911
75912
75913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
75914   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75915
75916   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75917   {
75918     try {
75919       (arg1)->Enable();
75920     } catch (std::out_of_range& e) {
75921       {
75922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75923       };
75924     } catch (std::exception& e) {
75925       {
75926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75927       };
75928     } catch (Dali::DaliException e) {
75929       {
75930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75931       };
75932     } catch (...) {
75933       {
75934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75935       };
75936     }
75937   }
75938
75939 }
75940
75941
75942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
75943   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75944
75945   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75946   {
75947     try {
75948       (arg1)->Disable();
75949     } catch (std::out_of_range& e) {
75950       {
75951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75952       };
75953     } catch (std::exception& e) {
75954       {
75955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75956       };
75957     } catch (Dali::DaliException e) {
75958       {
75959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75960       };
75961     } catch (...) {
75962       {
75963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75964       };
75965     }
75966   }
75967
75968 }
75969
75970
75971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
75972   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
75973   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
75974   Dali::Toolkit::RulerDomain *argp2 ;
75975
75976   arg1 = (Dali::Toolkit::Ruler *)jarg1;
75977   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
75978   if (!argp2) {
75979     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
75980     return ;
75981   }
75982   arg2 = *argp2;
75983   {
75984     try {
75985       (arg1)->SetDomain(arg2);
75986     } catch (std::out_of_range& e) {
75987       {
75988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75989       };
75990     } catch (std::exception& e) {
75991       {
75992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75993       };
75994     } catch (Dali::DaliException e) {
75995       {
75996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75997       };
75998     } catch (...) {
75999       {
76000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76001       };
76002     }
76003   }
76004
76005 }
76006
76007
76008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
76009   void * jresult ;
76010   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76011   Dali::Toolkit::RulerDomain *result = 0 ;
76012
76013   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76014   {
76015     try {
76016       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
76017     } catch (std::out_of_range& e) {
76018       {
76019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76020       };
76021     } catch (std::exception& e) {
76022       {
76023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76024       };
76025     } catch (Dali::DaliException e) {
76026       {
76027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76028       };
76029     } catch (...) {
76030       {
76031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76032       };
76033     }
76034   }
76035
76036   jresult = (void *)result;
76037   return jresult;
76038 }
76039
76040
76041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
76042   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76043
76044   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76045   {
76046     try {
76047       (arg1)->DisableDomain();
76048     } catch (std::out_of_range& e) {
76049       {
76050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76051       };
76052     } catch (std::exception& e) {
76053       {
76054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76055       };
76056     } catch (Dali::DaliException e) {
76057       {
76058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76059       };
76060     } catch (...) {
76061       {
76062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76063       };
76064     }
76065   }
76066
76067 }
76068
76069
76070 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
76071   float jresult ;
76072   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76073   float arg2 ;
76074   float arg3 ;
76075   float arg4 ;
76076   float result;
76077
76078   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76079   arg2 = (float)jarg2;
76080   arg3 = (float)jarg3;
76081   arg4 = (float)jarg4;
76082   {
76083     try {
76084       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
76085     } catch (std::out_of_range& e) {
76086       {
76087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76088       };
76089     } catch (std::exception& e) {
76090       {
76091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76092       };
76093     } catch (Dali::DaliException e) {
76094       {
76095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76096       };
76097     } catch (...) {
76098       {
76099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76100       };
76101     }
76102   }
76103
76104   jresult = result;
76105   return jresult;
76106 }
76107
76108
76109 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
76110   float jresult ;
76111   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76112   float arg2 ;
76113   float arg3 ;
76114   float result;
76115
76116   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76117   arg2 = (float)jarg2;
76118   arg3 = (float)jarg3;
76119   {
76120     try {
76121       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
76122     } catch (std::out_of_range& e) {
76123       {
76124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76125       };
76126     } catch (std::exception& e) {
76127       {
76128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76129       };
76130     } catch (Dali::DaliException e) {
76131       {
76132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76133       };
76134     } catch (...) {
76135       {
76136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76137       };
76138     }
76139   }
76140
76141   jresult = result;
76142   return jresult;
76143 }
76144
76145
76146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
76147   float jresult ;
76148   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76149   float arg2 ;
76150   float result;
76151
76152   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76153   arg2 = (float)jarg2;
76154   {
76155     try {
76156       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
76157     } catch (std::out_of_range& e) {
76158       {
76159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76160       };
76161     } catch (std::exception& e) {
76162       {
76163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76164       };
76165     } catch (Dali::DaliException e) {
76166       {
76167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76168       };
76169     } catch (...) {
76170       {
76171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76172       };
76173     }
76174   }
76175
76176   jresult = result;
76177   return jresult;
76178 }
76179
76180
76181 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
76182   float jresult ;
76183   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76184   float arg2 ;
76185   float arg3 ;
76186   float arg4 ;
76187   Dali::Toolkit::ClampState *arg5 = 0 ;
76188   float result;
76189
76190   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76191   arg2 = (float)jarg2;
76192   arg3 = (float)jarg3;
76193   arg4 = (float)jarg4;
76194   arg5 = (Dali::Toolkit::ClampState *)jarg5;
76195   if (!arg5) {
76196     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76197     return 0;
76198   }
76199   {
76200     try {
76201       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
76202     } catch (std::out_of_range& e) {
76203       {
76204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76205       };
76206     } catch (std::exception& e) {
76207       {
76208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76209       };
76210     } catch (Dali::DaliException e) {
76211       {
76212         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76213       };
76214     } catch (...) {
76215       {
76216         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76217       };
76218     }
76219   }
76220
76221   jresult = result;
76222   return jresult;
76223 }
76224
76225
76226 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
76227   float jresult ;
76228   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76229   float arg2 ;
76230   float arg3 ;
76231   float arg4 ;
76232   float arg5 ;
76233   float result;
76234
76235   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76236   arg2 = (float)jarg2;
76237   arg3 = (float)jarg3;
76238   arg4 = (float)jarg4;
76239   arg5 = (float)jarg5;
76240   {
76241     try {
76242       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
76243     } catch (std::out_of_range& e) {
76244       {
76245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76246       };
76247     } catch (std::exception& e) {
76248       {
76249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76250       };
76251     } catch (Dali::DaliException e) {
76252       {
76253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76254       };
76255     } catch (...) {
76256       {
76257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76258       };
76259     }
76260   }
76261
76262   jresult = result;
76263   return jresult;
76264 }
76265
76266
76267 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
76268   float jresult ;
76269   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76270   float arg2 ;
76271   float arg3 ;
76272   float arg4 ;
76273   float result;
76274
76275   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76276   arg2 = (float)jarg2;
76277   arg3 = (float)jarg3;
76278   arg4 = (float)jarg4;
76279   {
76280     try {
76281       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
76282     } catch (std::out_of_range& e) {
76283       {
76284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76285       };
76286     } catch (std::exception& e) {
76287       {
76288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76289       };
76290     } catch (Dali::DaliException e) {
76291       {
76292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76293       };
76294     } catch (...) {
76295       {
76296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76297       };
76298     }
76299   }
76300
76301   jresult = result;
76302   return jresult;
76303 }
76304
76305
76306 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
76307   float jresult ;
76308   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76309   float arg2 ;
76310   float arg3 ;
76311   float result;
76312
76313   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76314   arg2 = (float)jarg2;
76315   arg3 = (float)jarg3;
76316   {
76317     try {
76318       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
76319     } catch (std::out_of_range& e) {
76320       {
76321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76322       };
76323     } catch (std::exception& e) {
76324       {
76325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76326       };
76327     } catch (Dali::DaliException e) {
76328       {
76329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76330       };
76331     } catch (...) {
76332       {
76333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76334       };
76335     }
76336   }
76337
76338   jresult = result;
76339   return jresult;
76340 }
76341
76342
76343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
76344   float jresult ;
76345   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76346   float arg2 ;
76347   float result;
76348
76349   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76350   arg2 = (float)jarg2;
76351   {
76352     try {
76353       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
76354     } catch (std::out_of_range& e) {
76355       {
76356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76357       };
76358     } catch (std::exception& e) {
76359       {
76360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76361       };
76362     } catch (Dali::DaliException e) {
76363       {
76364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76365       };
76366     } catch (...) {
76367       {
76368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76369       };
76370     }
76371   }
76372
76373   jresult = result;
76374   return jresult;
76375 }
76376
76377
76378 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
76379   float jresult ;
76380   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
76381   float arg2 ;
76382   float arg3 ;
76383   float arg4 ;
76384   float arg5 ;
76385   Dali::Toolkit::ClampState *arg6 = 0 ;
76386   float result;
76387
76388   arg1 = (Dali::Toolkit::Ruler *)jarg1;
76389   arg2 = (float)jarg2;
76390   arg3 = (float)jarg3;
76391   arg4 = (float)jarg4;
76392   arg5 = (float)jarg5;
76393   arg6 = (Dali::Toolkit::ClampState *)jarg6;
76394   if (!arg6) {
76395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
76396     return 0;
76397   }
76398   {
76399     try {
76400       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
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 (Dali::DaliException e) {
76410       {
76411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76412       };
76413     } catch (...) {
76414       {
76415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76416       };
76417     }
76418   }
76419
76420   jresult = result;
76421   return jresult;
76422 }
76423
76424
76425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
76426   void * jresult ;
76427   Dali::Toolkit::DefaultRuler *result = 0 ;
76428
76429   {
76430     try {
76431       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
76432     } catch (std::out_of_range& e) {
76433       {
76434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76435       };
76436     } catch (std::exception& e) {
76437       {
76438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76439       };
76440     } catch (Dali::DaliException e) {
76441       {
76442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76443       };
76444     } catch (...) {
76445       {
76446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76447       };
76448     }
76449   }
76450
76451   jresult = (void *)result;
76452   return jresult;
76453 }
76454
76455
76456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
76457   float jresult ;
76458   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
76459   float arg2 ;
76460   float arg3 ;
76461   float result;
76462
76463   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
76464   arg2 = (float)jarg2;
76465   arg3 = (float)jarg3;
76466   {
76467     try {
76468       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
76469     } catch (std::out_of_range& e) {
76470       {
76471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76472       };
76473     } catch (std::exception& e) {
76474       {
76475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76476       };
76477     } catch (Dali::DaliException e) {
76478       {
76479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76480       };
76481     } catch (...) {
76482       {
76483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76484       };
76485     }
76486   }
76487
76488   jresult = result;
76489   return jresult;
76490 }
76491
76492
76493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
76494   float jresult ;
76495   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
76496   unsigned int arg2 ;
76497   unsigned int *arg3 = 0 ;
76498   bool arg4 ;
76499   float result;
76500
76501   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
76502   arg2 = (unsigned int)jarg2;
76503   arg3 = (unsigned int *)jarg3;
76504   arg4 = jarg4 ? true : false;
76505   {
76506     try {
76507       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
76508     } catch (std::out_of_range& e) {
76509       {
76510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76511       };
76512     } catch (std::exception& e) {
76513       {
76514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76515       };
76516     } catch (Dali::DaliException e) {
76517       {
76518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76519       };
76520     } catch (...) {
76521       {
76522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76523       };
76524     }
76525   }
76526
76527   jresult = result;
76528   return jresult;
76529 }
76530
76531
76532 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
76533   unsigned int jresult ;
76534   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
76535   float arg2 ;
76536   bool arg3 ;
76537   unsigned int result;
76538
76539   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
76540   arg2 = (float)jarg2;
76541   arg3 = jarg3 ? true : false;
76542   {
76543     try {
76544       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
76545     } catch (std::out_of_range& e) {
76546       {
76547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76548       };
76549     } catch (std::exception& e) {
76550       {
76551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76552       };
76553     } catch (Dali::DaliException e) {
76554       {
76555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76556       };
76557     } catch (...) {
76558       {
76559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76560       };
76561     }
76562   }
76563
76564   jresult = result;
76565   return jresult;
76566 }
76567
76568
76569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
76570   unsigned int jresult ;
76571   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
76572   unsigned int result;
76573
76574   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
76575   {
76576     try {
76577       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
76578     } catch (std::out_of_range& e) {
76579       {
76580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76581       };
76582     } catch (std::exception& e) {
76583       {
76584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76585       };
76586     } catch (Dali::DaliException e) {
76587       {
76588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76589       };
76590     } catch (...) {
76591       {
76592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76593       };
76594     }
76595   }
76596
76597   jresult = result;
76598   return jresult;
76599 }
76600
76601
76602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
76603   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
76604
76605   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
76606   {
76607     try {
76608       delete arg1;
76609     } catch (std::out_of_range& e) {
76610       {
76611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76612       };
76613     } catch (std::exception& e) {
76614       {
76615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76616       };
76617     } catch (Dali::DaliException e) {
76618       {
76619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76620       };
76621     } catch (...) {
76622       {
76623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76624       };
76625     }
76626   }
76627
76628 }
76629
76630
76631 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
76632   void * jresult ;
76633   float arg1 ;
76634   Dali::Toolkit::FixedRuler *result = 0 ;
76635
76636   arg1 = (float)jarg1;
76637   {
76638     try {
76639       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
76640     } catch (std::out_of_range& e) {
76641       {
76642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76643       };
76644     } catch (std::exception& e) {
76645       {
76646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76647       };
76648     } catch (Dali::DaliException e) {
76649       {
76650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76651       };
76652     } catch (...) {
76653       {
76654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76655       };
76656     }
76657   }
76658
76659   jresult = (void *)result;
76660   return jresult;
76661 }
76662
76663
76664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
76665   void * jresult ;
76666   Dali::Toolkit::FixedRuler *result = 0 ;
76667
76668   {
76669     try {
76670       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
76671     } catch (std::out_of_range& e) {
76672       {
76673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76674       };
76675     } catch (std::exception& e) {
76676       {
76677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76678       };
76679     } catch (Dali::DaliException e) {
76680       {
76681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76682       };
76683     } catch (...) {
76684       {
76685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76686       };
76687     }
76688   }
76689
76690   jresult = (void *)result;
76691   return jresult;
76692 }
76693
76694
76695 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
76696   float jresult ;
76697   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
76698   float arg2 ;
76699   float arg3 ;
76700   float result;
76701
76702   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
76703   arg2 = (float)jarg2;
76704   arg3 = (float)jarg3;
76705   {
76706     try {
76707       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
76708     } catch (std::out_of_range& e) {
76709       {
76710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76711       };
76712     } catch (std::exception& e) {
76713       {
76714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76715       };
76716     } catch (Dali::DaliException e) {
76717       {
76718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76719       };
76720     } catch (...) {
76721       {
76722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76723       };
76724     }
76725   }
76726
76727   jresult = result;
76728   return jresult;
76729 }
76730
76731
76732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
76733   float jresult ;
76734   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
76735   unsigned int arg2 ;
76736   unsigned int *arg3 = 0 ;
76737   bool arg4 ;
76738   float result;
76739
76740   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
76741   arg2 = (unsigned int)jarg2;
76742   arg3 = (unsigned int *)jarg3;
76743   arg4 = jarg4 ? true : false;
76744   {
76745     try {
76746       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
76747     } catch (std::out_of_range& e) {
76748       {
76749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76750       };
76751     } catch (std::exception& e) {
76752       {
76753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76754       };
76755     } catch (Dali::DaliException e) {
76756       {
76757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76758       };
76759     } catch (...) {
76760       {
76761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76762       };
76763     }
76764   }
76765
76766   jresult = result;
76767   return jresult;
76768 }
76769
76770
76771 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
76772   unsigned int jresult ;
76773   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
76774   float arg2 ;
76775   bool arg3 ;
76776   unsigned int result;
76777
76778   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
76779   arg2 = (float)jarg2;
76780   arg3 = jarg3 ? true : false;
76781   {
76782     try {
76783       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
76784     } catch (std::out_of_range& e) {
76785       {
76786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76787       };
76788     } catch (std::exception& e) {
76789       {
76790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76791       };
76792     } catch (Dali::DaliException e) {
76793       {
76794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76795       };
76796     } catch (...) {
76797       {
76798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76799       };
76800     }
76801   }
76802
76803   jresult = result;
76804   return jresult;
76805 }
76806
76807
76808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
76809   unsigned int jresult ;
76810   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
76811   unsigned int result;
76812
76813   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
76814   {
76815     try {
76816       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
76817     } catch (std::out_of_range& e) {
76818       {
76819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76820       };
76821     } catch (std::exception& e) {
76822       {
76823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76824       };
76825     } catch (Dali::DaliException e) {
76826       {
76827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76828       };
76829     } catch (...) {
76830       {
76831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76832       };
76833     }
76834   }
76835
76836   jresult = result;
76837   return jresult;
76838 }
76839
76840
76841 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
76842   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
76843
76844   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
76845   {
76846     try {
76847       delete arg1;
76848     } catch (std::out_of_range& e) {
76849       {
76850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76851       };
76852     } catch (std::exception& e) {
76853       {
76854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76855       };
76856     } catch (Dali::DaliException e) {
76857       {
76858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76859       };
76860     } catch (...) {
76861       {
76862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76863       };
76864     }
76865   }
76866
76867 }
76868
76869
76870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
76871   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76872   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
76873
76874   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76875   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
76876   if (arg1) (arg1)->scale = *arg2;
76877 }
76878
76879
76880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
76881   void * jresult ;
76882   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76883   Dali::Toolkit::ClampState2D *result = 0 ;
76884
76885   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76886   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
76887   jresult = (void *)result;
76888   return jresult;
76889 }
76890
76891
76892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
76893   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76894   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
76895
76896   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76897   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
76898   if (arg1) (arg1)->position = *arg2;
76899 }
76900
76901
76902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
76903   void * jresult ;
76904   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76905   Dali::Toolkit::ClampState2D *result = 0 ;
76906
76907   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76908   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
76909   jresult = (void *)result;
76910   return jresult;
76911 }
76912
76913
76914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
76915   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76916   Dali::Toolkit::ClampState arg2 ;
76917
76918   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76919   arg2 = (Dali::Toolkit::ClampState)jarg2;
76920   if (arg1) (arg1)->rotation = arg2;
76921 }
76922
76923
76924 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
76925   int jresult ;
76926   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76927   Dali::Toolkit::ClampState result;
76928
76929   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76930   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
76931   jresult = (int)result;
76932   return jresult;
76933 }
76934
76935
76936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
76937   void * jresult ;
76938   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
76939
76940   {
76941     try {
76942       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
76943     } catch (std::out_of_range& e) {
76944       {
76945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76946       };
76947     } catch (std::exception& e) {
76948       {
76949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76950       };
76951     } catch (Dali::DaliException e) {
76952       {
76953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76954       };
76955     } catch (...) {
76956       {
76957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76958       };
76959     }
76960   }
76961
76962   jresult = (void *)result;
76963   return jresult;
76964 }
76965
76966
76967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
76968   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
76969
76970   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
76971   {
76972     try {
76973       delete arg1;
76974     } catch (std::out_of_range& e) {
76975       {
76976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76977       };
76978     } catch (std::exception& e) {
76979       {
76980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76981       };
76982     } catch (Dali::DaliException e) {
76983       {
76984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76985       };
76986     } catch (...) {
76987       {
76988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76989       };
76990     }
76991   }
76992
76993 }
76994
76995
76996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
76997   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
76998   Dali::Toolkit::SnapType arg2 ;
76999
77000   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
77001   arg2 = (Dali::Toolkit::SnapType)jarg2;
77002   if (arg1) (arg1)->type = arg2;
77003 }
77004
77005
77006 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
77007   int jresult ;
77008   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
77009   Dali::Toolkit::SnapType result;
77010
77011   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
77012   result = (Dali::Toolkit::SnapType) ((arg1)->type);
77013   jresult = (int)result;
77014   return jresult;
77015 }
77016
77017
77018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
77019   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
77020   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
77021
77022   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
77023   arg2 = (Dali::Vector2 *)jarg2;
77024   if (arg1) (arg1)->position = *arg2;
77025 }
77026
77027
77028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
77029   void * jresult ;
77030   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
77031   Dali::Vector2 *result = 0 ;
77032
77033   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
77034   result = (Dali::Vector2 *)& ((arg1)->position);
77035   jresult = (void *)result;
77036   return jresult;
77037 }
77038
77039
77040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
77041   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
77042   float arg2 ;
77043
77044   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
77045   arg2 = (float)jarg2;
77046   if (arg1) (arg1)->duration = arg2;
77047 }
77048
77049
77050 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
77051   float jresult ;
77052   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
77053   float result;
77054
77055   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
77056   result = (float) ((arg1)->duration);
77057   jresult = result;
77058   return jresult;
77059 }
77060
77061
77062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
77063   void * jresult ;
77064   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
77065
77066   {
77067     try {
77068       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
77069     } catch (std::out_of_range& e) {
77070       {
77071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77072       };
77073     } catch (std::exception& e) {
77074       {
77075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77076       };
77077     } catch (Dali::DaliException e) {
77078       {
77079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77080       };
77081     } catch (...) {
77082       {
77083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77084       };
77085     }
77086   }
77087
77088   jresult = (void *)result;
77089   return jresult;
77090 }
77091
77092
77093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
77094   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
77095
77096   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
77097   {
77098     try {
77099       delete arg1;
77100     } catch (std::out_of_range& e) {
77101       {
77102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77103       };
77104     } catch (std::exception& e) {
77105       {
77106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77107       };
77108     } catch (Dali::DaliException e) {
77109       {
77110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77111       };
77112     } catch (...) {
77113       {
77114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77115       };
77116     }
77117   }
77118
77119 }
77120
77121
77122 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
77123   int jresult ;
77124   int result;
77125
77126   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
77127   jresult = (int)result;
77128   return jresult;
77129 }
77130
77131
77132 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
77133   int jresult ;
77134   int result;
77135
77136   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
77137   jresult = (int)result;
77138   return jresult;
77139 }
77140
77141
77142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
77143   int jresult ;
77144   int result;
77145
77146   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
77147   jresult = (int)result;
77148   return jresult;
77149 }
77150
77151
77152 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
77153   int jresult ;
77154   int result;
77155
77156   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
77157   jresult = (int)result;
77158   return jresult;
77159 }
77160
77161
77162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
77163   int jresult ;
77164   int result;
77165
77166   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
77167   jresult = (int)result;
77168   return jresult;
77169 }
77170
77171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
77172   int jresult ;
77173   int result;
77174
77175   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
77176   jresult = (int)result;
77177   return jresult;
77178 }
77179
77180
77181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
77182   int jresult ;
77183   int result;
77184
77185   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
77186   jresult = (int)result;
77187   return jresult;
77188 }
77189
77190
77191 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
77192   int jresult ;
77193   int result;
77194
77195   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
77196   jresult = (int)result;
77197   return jresult;
77198 }
77199
77200
77201 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
77202   int jresult ;
77203   int result;
77204
77205   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
77206   jresult = (int)result;
77207   return jresult;
77208 }
77209
77210
77211 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
77212   int jresult ;
77213   int result;
77214
77215   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
77216   jresult = (int)result;
77217   return jresult;
77218 }
77219
77220
77221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
77222   int jresult ;
77223   int result;
77224
77225   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
77226   jresult = (int)result;
77227   return jresult;
77228 }
77229
77230
77231 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
77232   int jresult ;
77233   int result;
77234
77235   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
77236   jresult = (int)result;
77237   return jresult;
77238 }
77239
77240
77241 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
77242   int jresult ;
77243   int result;
77244
77245   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
77246   jresult = (int)result;
77247   return jresult;
77248 }
77249
77250
77251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
77252   int jresult ;
77253   int result;
77254
77255   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
77256   jresult = (int)result;
77257   return jresult;
77258 }
77259
77260
77261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
77262   int jresult ;
77263   int result;
77264
77265   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
77266   jresult = (int)result;
77267   return jresult;
77268 }
77269
77270
77271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
77272   int jresult ;
77273   int result;
77274
77275   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
77276   jresult = (int)result;
77277   return jresult;
77278 }
77279
77280
77281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
77282   int jresult ;
77283   int result;
77284
77285   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
77286   jresult = (int)result;
77287   return jresult;
77288 }
77289
77290
77291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
77292   int jresult ;
77293   int result;
77294
77295   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
77296   jresult = (int)result;
77297   return jresult;
77298 }
77299
77300
77301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
77302   int jresult ;
77303   int result;
77304
77305   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
77306   jresult = (int)result;
77307   return jresult;
77308 }
77309
77310
77311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
77312   int jresult ;
77313   int result;
77314
77315   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
77316   jresult = (int)result;
77317   return jresult;
77318 }
77319
77320
77321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
77322   int jresult ;
77323   int result;
77324
77325   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
77326   jresult = (int)result;
77327   return jresult;
77328 }
77329
77330
77331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
77332   int jresult ;
77333   int result;
77334
77335   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
77336   jresult = (int)result;
77337   return jresult;
77338 }
77339
77340
77341 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
77342   int jresult ;
77343   int result;
77344
77345   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
77346   jresult = (int)result;
77347   return jresult;
77348 }
77349
77350
77351 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
77352   int jresult ;
77353   int result;
77354
77355   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
77356   jresult = (int)result;
77357   return jresult;
77358 }
77359
77360
77361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
77362   int jresult ;
77363   int result;
77364
77365   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
77366   jresult = (int)result;
77367   return jresult;
77368 }
77369
77370
77371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
77372   int jresult ;
77373   int result;
77374
77375   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
77376   jresult = (int)result;
77377   return jresult;
77378 }
77379
77380
77381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
77382   void * jresult ;
77383   Dali::Toolkit::ScrollView::Property *result = 0 ;
77384
77385   {
77386     try {
77387       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
77388     } catch (std::out_of_range& e) {
77389       {
77390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77391       };
77392     } catch (std::exception& e) {
77393       {
77394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77395       };
77396     } catch (Dali::DaliException e) {
77397       {
77398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77399       };
77400     } catch (...) {
77401       {
77402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77403       };
77404     }
77405   }
77406
77407   jresult = (void *)result;
77408   return jresult;
77409 }
77410
77411
77412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
77413   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
77414
77415   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
77416   {
77417     try {
77418       delete arg1;
77419     } catch (std::out_of_range& e) {
77420       {
77421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77422       };
77423     } catch (std::exception& e) {
77424       {
77425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77426       };
77427     } catch (Dali::DaliException e) {
77428       {
77429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77430       };
77431     } catch (...) {
77432       {
77433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77434       };
77435     }
77436   }
77437
77438 }
77439
77440
77441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
77442   void * jresult ;
77443   Dali::Toolkit::ScrollView *result = 0 ;
77444
77445   {
77446     try {
77447       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
77448     } catch (std::out_of_range& e) {
77449       {
77450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77451       };
77452     } catch (std::exception& e) {
77453       {
77454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77455       };
77456     } catch (Dali::DaliException e) {
77457       {
77458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77459       };
77460     } catch (...) {
77461       {
77462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77463       };
77464     }
77465   }
77466
77467   jresult = (void *)result;
77468   return jresult;
77469 }
77470
77471
77472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
77473   void * jresult ;
77474   Dali::Toolkit::ScrollView *arg1 = 0 ;
77475   Dali::Toolkit::ScrollView *result = 0 ;
77476
77477   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77478   if (!arg1) {
77479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
77480     return 0;
77481   }
77482   {
77483     try {
77484       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
77485     } catch (std::out_of_range& e) {
77486       {
77487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77488       };
77489     } catch (std::exception& e) {
77490       {
77491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77492       };
77493     } catch (Dali::DaliException e) {
77494       {
77495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77496       };
77497     } catch (...) {
77498       {
77499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77500       };
77501     }
77502   }
77503
77504   jresult = (void *)result;
77505   return jresult;
77506 }
77507
77508
77509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
77510   void * jresult ;
77511   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77512   Dali::Toolkit::ScrollView *arg2 = 0 ;
77513   Dali::Toolkit::ScrollView *result = 0 ;
77514
77515   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77516   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
77517   if (!arg2) {
77518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
77519     return 0;
77520   }
77521   {
77522     try {
77523       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
77524     } catch (std::out_of_range& e) {
77525       {
77526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77527       };
77528     } catch (std::exception& e) {
77529       {
77530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77531       };
77532     } catch (Dali::DaliException e) {
77533       {
77534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77535       };
77536     } catch (...) {
77537       {
77538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77539       };
77540     }
77541   }
77542
77543   jresult = (void *)result;
77544   return jresult;
77545 }
77546
77547
77548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
77549   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77550
77551   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77552   {
77553     try {
77554       delete arg1;
77555     } catch (std::out_of_range& e) {
77556       {
77557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77558       };
77559     } catch (std::exception& e) {
77560       {
77561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77562       };
77563     } catch (Dali::DaliException e) {
77564       {
77565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77566       };
77567     } catch (...) {
77568       {
77569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77570       };
77571     }
77572   }
77573
77574 }
77575
77576
77577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
77578   void * jresult ;
77579   Dali::Toolkit::ScrollView result;
77580
77581   {
77582     try {
77583       result = Dali::Toolkit::ScrollView::New();
77584     } catch (std::out_of_range& e) {
77585       {
77586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77587       };
77588     } catch (std::exception& e) {
77589       {
77590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77591       };
77592     } catch (Dali::DaliException e) {
77593       {
77594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77595       };
77596     } catch (...) {
77597       {
77598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77599       };
77600     }
77601   }
77602
77603   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
77604   return jresult;
77605 }
77606
77607
77608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
77609   void * jresult ;
77610   Dali::BaseHandle arg1 ;
77611   Dali::BaseHandle *argp1 ;
77612   Dali::Toolkit::ScrollView result;
77613
77614   argp1 = (Dali::BaseHandle *)jarg1;
77615   if (!argp1) {
77616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77617     return 0;
77618   }
77619   arg1 = *argp1;
77620   {
77621     try {
77622       result = Dali::Toolkit::ScrollView::DownCast(arg1);
77623     } catch (std::out_of_range& e) {
77624       {
77625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77626       };
77627     } catch (std::exception& e) {
77628       {
77629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77630       };
77631     } catch (Dali::DaliException e) {
77632       {
77633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77634       };
77635     } catch (...) {
77636       {
77637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77638       };
77639     }
77640   }
77641
77642   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
77643   return jresult;
77644 }
77645
77646
77647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
77648   void * jresult ;
77649   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77650   Dali::AlphaFunction result;
77651
77652   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77653   {
77654     try {
77655       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
77656     } catch (std::out_of_range& e) {
77657       {
77658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77659       };
77660     } catch (std::exception& e) {
77661       {
77662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77663       };
77664     } catch (Dali::DaliException e) {
77665       {
77666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77667       };
77668     } catch (...) {
77669       {
77670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77671       };
77672     }
77673   }
77674
77675   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
77676   return jresult;
77677 }
77678
77679
77680 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
77681   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77682   Dali::AlphaFunction arg2 ;
77683   Dali::AlphaFunction *argp2 ;
77684
77685   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77686   argp2 = (Dali::AlphaFunction *)jarg2;
77687   if (!argp2) {
77688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
77689     return ;
77690   }
77691   arg2 = *argp2;
77692   {
77693     try {
77694       (arg1)->SetScrollSnapAlphaFunction(arg2);
77695     } catch (std::out_of_range& e) {
77696       {
77697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77698       };
77699     } catch (std::exception& e) {
77700       {
77701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77702       };
77703     } catch (Dali::DaliException e) {
77704       {
77705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77706       };
77707     } catch (...) {
77708       {
77709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77710       };
77711     }
77712   }
77713
77714 }
77715
77716
77717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
77718   void * jresult ;
77719   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77720   Dali::AlphaFunction result;
77721
77722   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77723   {
77724     try {
77725       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
77726     } catch (std::out_of_range& e) {
77727       {
77728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77729       };
77730     } catch (std::exception& e) {
77731       {
77732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77733       };
77734     } catch (Dali::DaliException e) {
77735       {
77736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77737       };
77738     } catch (...) {
77739       {
77740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77741       };
77742     }
77743   }
77744
77745   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
77746   return jresult;
77747 }
77748
77749
77750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
77751   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77752   Dali::AlphaFunction arg2 ;
77753   Dali::AlphaFunction *argp2 ;
77754
77755   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77756   argp2 = (Dali::AlphaFunction *)jarg2;
77757   if (!argp2) {
77758     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
77759     return ;
77760   }
77761   arg2 = *argp2;
77762   {
77763     try {
77764       (arg1)->SetScrollFlickAlphaFunction(arg2);
77765     } catch (std::out_of_range& e) {
77766       {
77767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77768       };
77769     } catch (std::exception& e) {
77770       {
77771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77772       };
77773     } catch (Dali::DaliException e) {
77774       {
77775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77776       };
77777     } catch (...) {
77778       {
77779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77780       };
77781     }
77782   }
77783
77784 }
77785
77786
77787 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
77788   float jresult ;
77789   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77790   float result;
77791
77792   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77793   {
77794     try {
77795       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
77796     } catch (std::out_of_range& e) {
77797       {
77798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77799       };
77800     } catch (std::exception& e) {
77801       {
77802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77803       };
77804     } catch (Dali::DaliException e) {
77805       {
77806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77807       };
77808     } catch (...) {
77809       {
77810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77811       };
77812     }
77813   }
77814
77815   jresult = result;
77816   return jresult;
77817 }
77818
77819
77820 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
77821   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77822   float arg2 ;
77823
77824   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77825   arg2 = (float)jarg2;
77826   {
77827     try {
77828       (arg1)->SetScrollSnapDuration(arg2);
77829     } catch (std::out_of_range& e) {
77830       {
77831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77832       };
77833     } catch (std::exception& e) {
77834       {
77835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77836       };
77837     } catch (Dali::DaliException e) {
77838       {
77839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77840       };
77841     } catch (...) {
77842       {
77843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77844       };
77845     }
77846   }
77847
77848 }
77849
77850
77851 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
77852   float jresult ;
77853   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77854   float result;
77855
77856   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77857   {
77858     try {
77859       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
77860     } catch (std::out_of_range& e) {
77861       {
77862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77863       };
77864     } catch (std::exception& e) {
77865       {
77866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77867       };
77868     } catch (Dali::DaliException e) {
77869       {
77870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77871       };
77872     } catch (...) {
77873       {
77874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77875       };
77876     }
77877   }
77878
77879   jresult = result;
77880   return jresult;
77881 }
77882
77883
77884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
77885   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77886   float arg2 ;
77887
77888   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77889   arg2 = (float)jarg2;
77890   {
77891     try {
77892       (arg1)->SetScrollFlickDuration(arg2);
77893     } catch (std::out_of_range& e) {
77894       {
77895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77896       };
77897     } catch (std::exception& e) {
77898       {
77899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77900       };
77901     } catch (Dali::DaliException e) {
77902       {
77903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77904       };
77905     } catch (...) {
77906       {
77907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77908       };
77909     }
77910   }
77911
77912 }
77913
77914
77915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
77916   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77917   Dali::Toolkit::RulerPtr arg2 ;
77918   Dali::Toolkit::RulerPtr *argp2 ;
77919
77920   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77921   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
77922   if (!argp2) {
77923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
77924     return ;
77925   }
77926   arg2 = *argp2;
77927   {
77928     try {
77929       (arg1)->SetRulerX(arg2);
77930     } catch (std::out_of_range& e) {
77931       {
77932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77933       };
77934     } catch (std::exception& e) {
77935       {
77936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77937       };
77938     } catch (Dali::DaliException e) {
77939       {
77940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77941       };
77942     } catch (...) {
77943       {
77944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77945       };
77946     }
77947   }
77948
77949 }
77950
77951
77952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
77953   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77954   Dali::Toolkit::RulerPtr arg2 ;
77955   Dali::Toolkit::RulerPtr *argp2 ;
77956
77957   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77958   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
77959   if (!argp2) {
77960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
77961     return ;
77962   }
77963   arg2 = *argp2;
77964   {
77965     try {
77966       (arg1)->SetRulerY(arg2);
77967     } catch (std::out_of_range& e) {
77968       {
77969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77970       };
77971     } catch (std::exception& e) {
77972       {
77973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77974       };
77975     } catch (Dali::DaliException e) {
77976       {
77977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77978       };
77979     } catch (...) {
77980       {
77981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77982       };
77983     }
77984   }
77985
77986 }
77987
77988
77989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
77990   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77991   bool arg2 ;
77992
77993   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77994   arg2 = jarg2 ? true : false;
77995   {
77996     try {
77997       (arg1)->SetScrollSensitive(arg2);
77998     } catch (std::out_of_range& e) {
77999       {
78000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78001       };
78002     } catch (std::exception& e) {
78003       {
78004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78005       };
78006     } catch (Dali::DaliException e) {
78007       {
78008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78009       };
78010     } catch (...) {
78011       {
78012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78013       };
78014     }
78015   }
78016
78017 }
78018
78019
78020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
78021   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78022   float arg2 ;
78023   float arg3 ;
78024
78025   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78026   arg2 = (float)jarg2;
78027   arg3 = (float)jarg3;
78028   {
78029     try {
78030       (arg1)->SetMaxOvershoot(arg2,arg3);
78031     } catch (std::out_of_range& e) {
78032       {
78033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78034       };
78035     } catch (std::exception& e) {
78036       {
78037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78038       };
78039     } catch (Dali::DaliException e) {
78040       {
78041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78042       };
78043     } catch (...) {
78044       {
78045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78046       };
78047     }
78048   }
78049
78050 }
78051
78052
78053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
78054   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78055   Dali::AlphaFunction arg2 ;
78056   Dali::AlphaFunction *argp2 ;
78057
78058   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78059   argp2 = (Dali::AlphaFunction *)jarg2;
78060   if (!argp2) {
78061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
78062     return ;
78063   }
78064   arg2 = *argp2;
78065   {
78066     try {
78067       (arg1)->SetSnapOvershootAlphaFunction(arg2);
78068     } catch (std::out_of_range& e) {
78069       {
78070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78071       };
78072     } catch (std::exception& e) {
78073       {
78074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78075       };
78076     } catch (Dali::DaliException e) {
78077       {
78078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78079       };
78080     } catch (...) {
78081       {
78082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78083       };
78084     }
78085   }
78086
78087 }
78088
78089
78090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
78091   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78092   float arg2 ;
78093
78094   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78095   arg2 = (float)jarg2;
78096   {
78097     try {
78098       (arg1)->SetSnapOvershootDuration(arg2);
78099     } catch (std::out_of_range& e) {
78100       {
78101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78102       };
78103     } catch (std::exception& e) {
78104       {
78105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78106       };
78107     } catch (Dali::DaliException e) {
78108       {
78109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78110       };
78111     } catch (...) {
78112       {
78113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78114       };
78115     }
78116   }
78117
78118 }
78119
78120
78121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
78122   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78123   bool arg2 ;
78124
78125   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78126   arg2 = jarg2 ? true : false;
78127   {
78128     try {
78129       (arg1)->SetActorAutoSnap(arg2);
78130     } catch (std::out_of_range& e) {
78131       {
78132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78133       };
78134     } catch (std::exception& e) {
78135       {
78136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78137       };
78138     } catch (Dali::DaliException e) {
78139       {
78140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78141       };
78142     } catch (...) {
78143       {
78144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78145       };
78146     }
78147   }
78148
78149 }
78150
78151
78152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
78153   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78154   bool arg2 ;
78155
78156   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78157   arg2 = jarg2 ? true : false;
78158   {
78159     try {
78160       (arg1)->SetWrapMode(arg2);
78161     } catch (std::out_of_range& e) {
78162       {
78163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78164       };
78165     } catch (std::exception& e) {
78166       {
78167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78168       };
78169     } catch (Dali::DaliException e) {
78170       {
78171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78172       };
78173     } catch (...) {
78174       {
78175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78176       };
78177     }
78178   }
78179
78180 }
78181
78182
78183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
78184   int jresult ;
78185   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78186   int result;
78187
78188   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78189   {
78190     try {
78191       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
78192     } catch (std::out_of_range& e) {
78193       {
78194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78195       };
78196     } catch (std::exception& e) {
78197       {
78198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78199       };
78200     } catch (Dali::DaliException e) {
78201       {
78202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78203       };
78204     } catch (...) {
78205       {
78206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78207       };
78208     }
78209   }
78210
78211   jresult = result;
78212   return jresult;
78213 }
78214
78215
78216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
78217   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78218   int arg2 ;
78219
78220   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78221   arg2 = (int)jarg2;
78222   {
78223     try {
78224       (arg1)->SetScrollUpdateDistance(arg2);
78225     } catch (std::out_of_range& e) {
78226       {
78227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78228       };
78229     } catch (std::exception& e) {
78230       {
78231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78232       };
78233     } catch (Dali::DaliException e) {
78234       {
78235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78236       };
78237     } catch (...) {
78238       {
78239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78240       };
78241     }
78242   }
78243
78244 }
78245
78246
78247 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
78248   unsigned int jresult ;
78249   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78250   bool result;
78251
78252   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78253   {
78254     try {
78255       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
78256     } catch (std::out_of_range& e) {
78257       {
78258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78259       };
78260     } catch (std::exception& e) {
78261       {
78262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78263       };
78264     } catch (Dali::DaliException e) {
78265       {
78266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78267       };
78268     } catch (...) {
78269       {
78270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78271       };
78272     }
78273   }
78274
78275   jresult = result;
78276   return jresult;
78277 }
78278
78279
78280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
78281   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78282   bool arg2 ;
78283
78284   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78285   arg2 = jarg2 ? true : false;
78286   {
78287     try {
78288       (arg1)->SetAxisAutoLock(arg2);
78289     } catch (std::out_of_range& e) {
78290       {
78291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78292       };
78293     } catch (std::exception& e) {
78294       {
78295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78296       };
78297     } catch (Dali::DaliException e) {
78298       {
78299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78300       };
78301     } catch (...) {
78302       {
78303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78304       };
78305     }
78306   }
78307
78308 }
78309
78310
78311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
78312   float jresult ;
78313   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78314   float result;
78315
78316   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78317   {
78318     try {
78319       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
78320     } catch (std::out_of_range& e) {
78321       {
78322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78323       };
78324     } catch (std::exception& e) {
78325       {
78326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78327       };
78328     } catch (Dali::DaliException e) {
78329       {
78330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78331       };
78332     } catch (...) {
78333       {
78334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78335       };
78336     }
78337   }
78338
78339   jresult = result;
78340   return jresult;
78341 }
78342
78343
78344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
78345   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78346   float arg2 ;
78347
78348   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78349   arg2 = (float)jarg2;
78350   {
78351     try {
78352       (arg1)->SetAxisAutoLockGradient(arg2);
78353     } catch (std::out_of_range& e) {
78354       {
78355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78356       };
78357     } catch (std::exception& e) {
78358       {
78359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78360       };
78361     } catch (Dali::DaliException e) {
78362       {
78363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78364       };
78365     } catch (...) {
78366       {
78367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78368       };
78369     }
78370   }
78371
78372 }
78373
78374
78375 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
78376   float jresult ;
78377   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78378   float result;
78379
78380   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78381   {
78382     try {
78383       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
78384     } catch (std::out_of_range& e) {
78385       {
78386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78387       };
78388     } catch (std::exception& e) {
78389       {
78390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78391       };
78392     } catch (Dali::DaliException e) {
78393       {
78394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78395       };
78396     } catch (...) {
78397       {
78398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78399       };
78400     }
78401   }
78402
78403   jresult = result;
78404   return jresult;
78405 }
78406
78407
78408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
78409   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78410   float arg2 ;
78411
78412   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78413   arg2 = (float)jarg2;
78414   {
78415     try {
78416       (arg1)->SetFrictionCoefficient(arg2);
78417     } catch (std::out_of_range& e) {
78418       {
78419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78420       };
78421     } catch (std::exception& e) {
78422       {
78423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78424       };
78425     } catch (Dali::DaliException e) {
78426       {
78427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78428       };
78429     } catch (...) {
78430       {
78431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78432       };
78433     }
78434   }
78435
78436 }
78437
78438
78439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
78440   float jresult ;
78441   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78442   float result;
78443
78444   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78445   {
78446     try {
78447       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
78448     } catch (std::out_of_range& e) {
78449       {
78450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78451       };
78452     } catch (std::exception& e) {
78453       {
78454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78455       };
78456     } catch (Dali::DaliException e) {
78457       {
78458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78459       };
78460     } catch (...) {
78461       {
78462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78463       };
78464     }
78465   }
78466
78467   jresult = result;
78468   return jresult;
78469 }
78470
78471
78472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
78473   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78474   float arg2 ;
78475
78476   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78477   arg2 = (float)jarg2;
78478   {
78479     try {
78480       (arg1)->SetFlickSpeedCoefficient(arg2);
78481     } catch (std::out_of_range& e) {
78482       {
78483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78484       };
78485     } catch (std::exception& e) {
78486       {
78487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78488       };
78489     } catch (Dali::DaliException e) {
78490       {
78491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78492       };
78493     } catch (...) {
78494       {
78495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78496       };
78497     }
78498   }
78499
78500 }
78501
78502
78503 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
78504   void * jresult ;
78505   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78506   Dali::Vector2 result;
78507
78508   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78509   {
78510     try {
78511       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
78512     } catch (std::out_of_range& e) {
78513       {
78514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78515       };
78516     } catch (std::exception& e) {
78517       {
78518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78519       };
78520     } catch (Dali::DaliException e) {
78521       {
78522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78523       };
78524     } catch (...) {
78525       {
78526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78527       };
78528     }
78529   }
78530
78531   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
78532   return jresult;
78533 }
78534
78535
78536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
78537   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78538   Dali::Vector2 *arg2 = 0 ;
78539
78540   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78541   arg2 = (Dali::Vector2 *)jarg2;
78542   if (!arg2) {
78543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78544     return ;
78545   }
78546   {
78547     try {
78548       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
78549     } catch (std::out_of_range& e) {
78550       {
78551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78552       };
78553     } catch (std::exception& e) {
78554       {
78555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78556       };
78557     } catch (Dali::DaliException e) {
78558       {
78559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78560       };
78561     } catch (...) {
78562       {
78563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78564       };
78565     }
78566   }
78567
78568 }
78569
78570
78571 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
78572   float jresult ;
78573   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78574   float result;
78575
78576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78577   {
78578     try {
78579       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
78580     } catch (std::out_of_range& e) {
78581       {
78582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78583       };
78584     } catch (std::exception& e) {
78585       {
78586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78587       };
78588     } catch (Dali::DaliException e) {
78589       {
78590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78591       };
78592     } catch (...) {
78593       {
78594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78595       };
78596     }
78597   }
78598
78599   jresult = result;
78600   return jresult;
78601 }
78602
78603
78604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
78605   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78606   float arg2 ;
78607
78608   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78609   arg2 = (float)jarg2;
78610   {
78611     try {
78612       (arg1)->SetMinimumSpeedForFlick(arg2);
78613     } catch (std::out_of_range& e) {
78614       {
78615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78616       };
78617     } catch (std::exception& e) {
78618       {
78619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78620       };
78621     } catch (Dali::DaliException e) {
78622       {
78623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78624       };
78625     } catch (...) {
78626       {
78627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78628       };
78629     }
78630   }
78631
78632 }
78633
78634
78635 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
78636   float jresult ;
78637   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78638   float result;
78639
78640   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78641   {
78642     try {
78643       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
78644     } catch (std::out_of_range& e) {
78645       {
78646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78647       };
78648     } catch (std::exception& e) {
78649       {
78650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78651       };
78652     } catch (Dali::DaliException e) {
78653       {
78654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78655       };
78656     } catch (...) {
78657       {
78658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78659       };
78660     }
78661   }
78662
78663   jresult = result;
78664   return jresult;
78665 }
78666
78667
78668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
78669   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78670   float arg2 ;
78671
78672   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78673   arg2 = (float)jarg2;
78674   {
78675     try {
78676       (arg1)->SetMaxFlickSpeed(arg2);
78677     } catch (std::out_of_range& e) {
78678       {
78679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78680       };
78681     } catch (std::exception& e) {
78682       {
78683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78684       };
78685     } catch (Dali::DaliException e) {
78686       {
78687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78688       };
78689     } catch (...) {
78690       {
78691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78692       };
78693     }
78694   }
78695
78696 }
78697
78698
78699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
78700   void * jresult ;
78701   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78702   Dali::Vector2 result;
78703
78704   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78705   {
78706     try {
78707       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
78708     } catch (std::out_of_range& e) {
78709       {
78710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78711       };
78712     } catch (std::exception& e) {
78713       {
78714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78715       };
78716     } catch (Dali::DaliException e) {
78717       {
78718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78719       };
78720     } catch (...) {
78721       {
78722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78723       };
78724     }
78725   }
78726
78727   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
78728   return jresult;
78729 }
78730
78731
78732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
78733   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78734   Dali::Vector2 arg2 ;
78735   Dali::Vector2 *argp2 ;
78736
78737   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78738   argp2 = (Dali::Vector2 *)jarg2;
78739   if (!argp2) {
78740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
78741     return ;
78742   }
78743   arg2 = *argp2;
78744   {
78745     try {
78746       (arg1)->SetWheelScrollDistanceStep(arg2);
78747     } catch (std::out_of_range& e) {
78748       {
78749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78750       };
78751     } catch (std::exception& e) {
78752       {
78753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78754       };
78755     } catch (Dali::DaliException e) {
78756       {
78757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78758       };
78759     } catch (...) {
78760       {
78761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78762       };
78763     }
78764   }
78765
78766 }
78767
78768
78769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
78770   void * jresult ;
78771   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78772   Dali::Vector2 result;
78773
78774   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78775   {
78776     try {
78777       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
78778     } catch (std::out_of_range& e) {
78779       {
78780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78781       };
78782     } catch (std::exception& e) {
78783       {
78784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78785       };
78786     } catch (Dali::DaliException e) {
78787       {
78788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78789       };
78790     } catch (...) {
78791       {
78792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78793       };
78794     }
78795   }
78796
78797   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
78798   return jresult;
78799 }
78800
78801
78802 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
78803   unsigned int jresult ;
78804   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78805   unsigned int result;
78806
78807   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78808   {
78809     try {
78810       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
78811     } catch (std::out_of_range& e) {
78812       {
78813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78814       };
78815     } catch (std::exception& e) {
78816       {
78817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78818       };
78819     } catch (Dali::DaliException e) {
78820       {
78821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78822       };
78823     } catch (...) {
78824       {
78825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78826       };
78827     }
78828   }
78829
78830   jresult = result;
78831   return jresult;
78832 }
78833
78834
78835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
78836   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78837   Dali::Vector2 *arg2 = 0 ;
78838
78839   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78840   arg2 = (Dali::Vector2 *)jarg2;
78841   if (!arg2) {
78842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78843     return ;
78844   }
78845   {
78846     try {
78847       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
78848     } catch (std::out_of_range& e) {
78849       {
78850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78851       };
78852     } catch (std::exception& e) {
78853       {
78854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78855       };
78856     } catch (Dali::DaliException e) {
78857       {
78858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78859       };
78860     } catch (...) {
78861       {
78862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78863       };
78864     }
78865   }
78866
78867 }
78868
78869
78870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
78871   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78872   Dali::Vector2 *arg2 = 0 ;
78873   float arg3 ;
78874
78875   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78876   arg2 = (Dali::Vector2 *)jarg2;
78877   if (!arg2) {
78878     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78879     return ;
78880   }
78881   arg3 = (float)jarg3;
78882   {
78883     try {
78884       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
78885     } catch (std::out_of_range& e) {
78886       {
78887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78888       };
78889     } catch (std::exception& e) {
78890       {
78891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78892       };
78893     } catch (Dali::DaliException e) {
78894       {
78895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78896       };
78897     } catch (...) {
78898       {
78899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78900       };
78901     }
78902   }
78903
78904 }
78905
78906
78907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
78908   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78909   Dali::Vector2 *arg2 = 0 ;
78910   float arg3 ;
78911   Dali::AlphaFunction arg4 ;
78912   Dali::AlphaFunction *argp4 ;
78913
78914   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78915   arg2 = (Dali::Vector2 *)jarg2;
78916   if (!arg2) {
78917     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78918     return ;
78919   }
78920   arg3 = (float)jarg3;
78921   argp4 = (Dali::AlphaFunction *)jarg4;
78922   if (!argp4) {
78923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
78924     return ;
78925   }
78926   arg4 = *argp4;
78927   {
78928     try {
78929       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
78930     } catch (std::out_of_range& e) {
78931       {
78932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78933       };
78934     } catch (std::exception& e) {
78935       {
78936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78937       };
78938     } catch (Dali::DaliException e) {
78939       {
78940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78941       };
78942     } catch (...) {
78943       {
78944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78945       };
78946     }
78947   }
78948
78949 }
78950
78951
78952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
78953   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78954   Dali::Vector2 *arg2 = 0 ;
78955   float arg3 ;
78956   Dali::Toolkit::DirectionBias arg4 ;
78957   Dali::Toolkit::DirectionBias arg5 ;
78958
78959   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
78960   arg2 = (Dali::Vector2 *)jarg2;
78961   if (!arg2) {
78962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
78963     return ;
78964   }
78965   arg3 = (float)jarg3;
78966   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
78967   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
78968   {
78969     try {
78970       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
78971     } catch (std::out_of_range& e) {
78972       {
78973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78974       };
78975     } catch (std::exception& e) {
78976       {
78977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78978       };
78979     } catch (Dali::DaliException e) {
78980       {
78981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78982       };
78983     } catch (...) {
78984       {
78985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78986       };
78987     }
78988   }
78989
78990 }
78991
78992
78993 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
78994   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
78995   Dali::Vector2 *arg2 = 0 ;
78996   float arg3 ;
78997   Dali::AlphaFunction arg4 ;
78998   Dali::Toolkit::DirectionBias arg5 ;
78999   Dali::Toolkit::DirectionBias arg6 ;
79000   Dali::AlphaFunction *argp4 ;
79001
79002   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79003   arg2 = (Dali::Vector2 *)jarg2;
79004   if (!arg2) {
79005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
79006     return ;
79007   }
79008   arg3 = (float)jarg3;
79009   argp4 = (Dali::AlphaFunction *)jarg4;
79010   if (!argp4) {
79011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
79012     return ;
79013   }
79014   arg4 = *argp4;
79015   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
79016   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
79017   {
79018     try {
79019       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
79020     } catch (std::out_of_range& e) {
79021       {
79022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79023       };
79024     } catch (std::exception& e) {
79025       {
79026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79027       };
79028     } catch (Dali::DaliException e) {
79029       {
79030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79031       };
79032     } catch (...) {
79033       {
79034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79035       };
79036     }
79037   }
79038
79039 }
79040
79041
79042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
79043   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79044   unsigned int arg2 ;
79045
79046   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79047   arg2 = (unsigned int)jarg2;
79048   {
79049     try {
79050       (arg1)->ScrollTo(arg2);
79051     } catch (std::out_of_range& e) {
79052       {
79053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79054       };
79055     } catch (std::exception& e) {
79056       {
79057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79058       };
79059     } catch (Dali::DaliException e) {
79060       {
79061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79062       };
79063     } catch (...) {
79064       {
79065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79066       };
79067     }
79068   }
79069
79070 }
79071
79072
79073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
79074   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79075   unsigned int arg2 ;
79076   float arg3 ;
79077
79078   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79079   arg2 = (unsigned int)jarg2;
79080   arg3 = (float)jarg3;
79081   {
79082     try {
79083       (arg1)->ScrollTo(arg2,arg3);
79084     } catch (std::out_of_range& e) {
79085       {
79086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79087       };
79088     } catch (std::exception& e) {
79089       {
79090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79091       };
79092     } catch (Dali::DaliException e) {
79093       {
79094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79095       };
79096     } catch (...) {
79097       {
79098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79099       };
79100     }
79101   }
79102
79103 }
79104
79105
79106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
79107   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79108   unsigned int arg2 ;
79109   float arg3 ;
79110   Dali::Toolkit::DirectionBias arg4 ;
79111
79112   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79113   arg2 = (unsigned int)jarg2;
79114   arg3 = (float)jarg3;
79115   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
79116   {
79117     try {
79118       (arg1)->ScrollTo(arg2,arg3,arg4);
79119     } catch (std::out_of_range& e) {
79120       {
79121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79122       };
79123     } catch (std::exception& e) {
79124       {
79125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79126       };
79127     } catch (Dali::DaliException e) {
79128       {
79129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79130       };
79131     } catch (...) {
79132       {
79133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79134       };
79135     }
79136   }
79137
79138 }
79139
79140
79141 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
79142   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79143   Dali::Actor *arg2 = 0 ;
79144
79145   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79146   arg2 = (Dali::Actor *)jarg2;
79147   if (!arg2) {
79148     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
79149     return ;
79150   }
79151   {
79152     try {
79153       (arg1)->ScrollTo(*arg2);
79154     } catch (std::out_of_range& e) {
79155       {
79156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79157       };
79158     } catch (std::exception& e) {
79159       {
79160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79161       };
79162     } catch (Dali::DaliException e) {
79163       {
79164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79165       };
79166     } catch (...) {
79167       {
79168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79169       };
79170     }
79171   }
79172
79173 }
79174
79175
79176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
79177   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79178   Dali::Actor *arg2 = 0 ;
79179   float arg3 ;
79180
79181   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79182   arg2 = (Dali::Actor *)jarg2;
79183   if (!arg2) {
79184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
79185     return ;
79186   }
79187   arg3 = (float)jarg3;
79188   {
79189     try {
79190       (arg1)->ScrollTo(*arg2,arg3);
79191     } catch (std::out_of_range& e) {
79192       {
79193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79194       };
79195     } catch (std::exception& e) {
79196       {
79197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79198       };
79199     } catch (Dali::DaliException e) {
79200       {
79201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79202       };
79203     } catch (...) {
79204       {
79205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79206       };
79207     }
79208   }
79209
79210 }
79211
79212
79213 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
79214   unsigned int jresult ;
79215   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79216   bool result;
79217
79218   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79219   {
79220     try {
79221       result = (bool)(arg1)->ScrollToSnapPoint();
79222     } catch (std::out_of_range& e) {
79223       {
79224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79225       };
79226     } catch (std::exception& e) {
79227       {
79228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79229       };
79230     } catch (Dali::DaliException e) {
79231       {
79232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79233       };
79234     } catch (...) {
79235       {
79236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79237       };
79238     }
79239   }
79240
79241   jresult = result;
79242   return jresult;
79243 }
79244
79245
79246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
79247   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79248   Dali::Constraint arg2 ;
79249   Dali::Constraint *argp2 ;
79250
79251   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79252   argp2 = (Dali::Constraint *)jarg2;
79253   if (!argp2) {
79254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
79255     return ;
79256   }
79257   arg2 = *argp2;
79258   {
79259     try {
79260       (arg1)->ApplyConstraintToChildren(arg2);
79261     } catch (std::out_of_range& e) {
79262       {
79263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79264       };
79265     } catch (std::exception& e) {
79266       {
79267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79268       };
79269     } catch (Dali::DaliException e) {
79270       {
79271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79272       };
79273     } catch (...) {
79274       {
79275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79276       };
79277     }
79278   }
79279
79280 }
79281
79282
79283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
79284   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79285
79286   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79287   {
79288     try {
79289       (arg1)->RemoveConstraintsFromChildren();
79290     } catch (std::out_of_range& e) {
79291       {
79292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79293       };
79294     } catch (std::exception& e) {
79295       {
79296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79297       };
79298     } catch (Dali::DaliException e) {
79299       {
79300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79301       };
79302     } catch (...) {
79303       {
79304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79305       };
79306     }
79307   }
79308
79309 }
79310
79311
79312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
79313   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79314   Dali::Toolkit::ScrollViewEffect arg2 ;
79315   Dali::Toolkit::ScrollViewEffect *argp2 ;
79316
79317   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79318   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
79319   if (!argp2) {
79320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
79321     return ;
79322   }
79323   arg2 = *argp2;
79324   {
79325     try {
79326       (arg1)->ApplyEffect(arg2);
79327     } catch (std::out_of_range& e) {
79328       {
79329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79330       };
79331     } catch (std::exception& e) {
79332       {
79333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79334       };
79335     } catch (Dali::DaliException e) {
79336       {
79337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79338       };
79339     } catch (...) {
79340       {
79341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79342       };
79343     }
79344   }
79345
79346 }
79347
79348
79349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
79350   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79351   Dali::Toolkit::ScrollViewEffect arg2 ;
79352   Dali::Toolkit::ScrollViewEffect *argp2 ;
79353
79354   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79355   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
79356   if (!argp2) {
79357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
79358     return ;
79359   }
79360   arg2 = *argp2;
79361   {
79362     try {
79363       (arg1)->RemoveEffect(arg2);
79364     } catch (std::out_of_range& e) {
79365       {
79366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79367       };
79368     } catch (std::exception& e) {
79369       {
79370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79371       };
79372     } catch (Dali::DaliException e) {
79373       {
79374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79375       };
79376     } catch (...) {
79377       {
79378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79379       };
79380     }
79381   }
79382
79383 }
79384
79385
79386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
79387   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79388
79389   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79390   {
79391     try {
79392       (arg1)->RemoveAllEffects();
79393     } catch (std::out_of_range& e) {
79394       {
79395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79396       };
79397     } catch (std::exception& e) {
79398       {
79399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79400       };
79401     } catch (Dali::DaliException e) {
79402       {
79403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79404       };
79405     } catch (...) {
79406       {
79407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79408       };
79409     }
79410   }
79411
79412 }
79413
79414
79415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
79416   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79417   Dali::Actor arg2 ;
79418   Dali::Actor *argp2 ;
79419
79420   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79421   argp2 = (Dali::Actor *)jarg2;
79422   if (!argp2) {
79423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79424     return ;
79425   }
79426   arg2 = *argp2;
79427   {
79428     try {
79429       (arg1)->BindActor(arg2);
79430     } catch (std::out_of_range& e) {
79431       {
79432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79433       };
79434     } catch (std::exception& e) {
79435       {
79436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79437       };
79438     } catch (Dali::DaliException e) {
79439       {
79440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79441       };
79442     } catch (...) {
79443       {
79444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79445       };
79446     }
79447   }
79448
79449 }
79450
79451
79452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
79453   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79454   Dali::Actor arg2 ;
79455   Dali::Actor *argp2 ;
79456
79457   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79458   argp2 = (Dali::Actor *)jarg2;
79459   if (!argp2) {
79460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79461     return ;
79462   }
79463   arg2 = *argp2;
79464   {
79465     try {
79466       (arg1)->UnbindActor(arg2);
79467     } catch (std::out_of_range& e) {
79468       {
79469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79470       };
79471     } catch (std::exception& e) {
79472       {
79473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79474       };
79475     } catch (Dali::DaliException e) {
79476       {
79477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79478       };
79479     } catch (...) {
79480       {
79481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79482       };
79483     }
79484   }
79485
79486 }
79487
79488
79489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
79490   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79491   Dali::Radian arg2 ;
79492   Dali::Radian arg3 ;
79493   Dali::Radian *argp2 ;
79494   Dali::Radian *argp3 ;
79495
79496   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79497   argp2 = (Dali::Radian *)jarg2;
79498   if (!argp2) {
79499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
79500     return ;
79501   }
79502   arg2 = *argp2;
79503   argp3 = (Dali::Radian *)jarg3;
79504   if (!argp3) {
79505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
79506     return ;
79507   }
79508   arg3 = *argp3;
79509   {
79510     try {
79511       (arg1)->SetScrollingDirection(arg2,arg3);
79512     } catch (std::out_of_range& e) {
79513       {
79514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79515       };
79516     } catch (std::exception& e) {
79517       {
79518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79519       };
79520     } catch (Dali::DaliException e) {
79521       {
79522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79523       };
79524     } catch (...) {
79525       {
79526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79527       };
79528     }
79529   }
79530
79531 }
79532
79533
79534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
79535   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79536   Dali::Radian arg2 ;
79537   Dali::Radian *argp2 ;
79538
79539   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79540   argp2 = (Dali::Radian *)jarg2;
79541   if (!argp2) {
79542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
79543     return ;
79544   }
79545   arg2 = *argp2;
79546   {
79547     try {
79548       (arg1)->SetScrollingDirection(arg2);
79549     } catch (std::out_of_range& e) {
79550       {
79551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79552       };
79553     } catch (std::exception& e) {
79554       {
79555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79556       };
79557     } catch (Dali::DaliException e) {
79558       {
79559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79560       };
79561     } catch (...) {
79562       {
79563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79564       };
79565     }
79566   }
79567
79568 }
79569
79570
79571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
79572   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79573   Dali::Radian arg2 ;
79574   Dali::Radian *argp2 ;
79575
79576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79577   argp2 = (Dali::Radian *)jarg2;
79578   if (!argp2) {
79579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
79580     return ;
79581   }
79582   arg2 = *argp2;
79583   {
79584     try {
79585       (arg1)->RemoveScrollingDirection(arg2);
79586     } catch (std::out_of_range& e) {
79587       {
79588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79589       };
79590     } catch (std::exception& e) {
79591       {
79592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79593       };
79594     } catch (Dali::DaliException e) {
79595       {
79596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79597       };
79598     } catch (...) {
79599       {
79600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79601       };
79602     }
79603   }
79604
79605 }
79606
79607
79608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
79609   void * jresult ;
79610   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
79611   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
79612
79613   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
79614   {
79615     try {
79616       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
79617     } catch (std::out_of_range& e) {
79618       {
79619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79620       };
79621     } catch (std::exception& e) {
79622       {
79623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79624       };
79625     } catch (Dali::DaliException e) {
79626       {
79627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79628       };
79629     } catch (...) {
79630       {
79631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79632       };
79633     }
79634   }
79635
79636   jresult = (void *)result;
79637   return jresult;
79638 }
79639
79640
79641 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
79642   int jresult ;
79643   int result;
79644
79645   result = (int)Dali::Toolkit::TableView::Property::ROWS;
79646   jresult = (int)result;
79647   return jresult;
79648 }
79649
79650
79651 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
79652   int jresult ;
79653   int result;
79654
79655   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
79656   jresult = (int)result;
79657   return jresult;
79658 }
79659
79660
79661 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
79662   int jresult ;
79663   int result;
79664
79665   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
79666   jresult = (int)result;
79667   return jresult;
79668 }
79669
79670
79671 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
79672   int jresult ;
79673   int result;
79674
79675   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
79676   jresult = (int)result;
79677   return jresult;
79678 }
79679
79680
79681 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
79682   int jresult ;
79683   int result;
79684
79685   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
79686   jresult = (int)result;
79687   return jresult;
79688 }
79689
79690
79691 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
79692   void * jresult ;
79693   Dali::Toolkit::TableView::Property *result = 0 ;
79694
79695   {
79696     try {
79697       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
79698     } catch (std::out_of_range& e) {
79699       {
79700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79701       };
79702     } catch (std::exception& e) {
79703       {
79704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79705       };
79706     } catch (Dali::DaliException e) {
79707       {
79708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79709       };
79710     } catch (...) {
79711       {
79712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79713       };
79714     }
79715   }
79716
79717   jresult = (void *)result;
79718   return jresult;
79719 }
79720
79721
79722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
79723   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
79724
79725   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
79726   {
79727     try {
79728       delete arg1;
79729     } catch (std::out_of_range& e) {
79730       {
79731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79732       };
79733     } catch (std::exception& e) {
79734       {
79735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79736       };
79737     } catch (Dali::DaliException e) {
79738       {
79739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79740       };
79741     } catch (...) {
79742       {
79743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79744       };
79745     }
79746   }
79747
79748 }
79749
79750
79751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
79752   int jresult ;
79753   int result;
79754
79755   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
79756   jresult = (int)result;
79757   return jresult;
79758 }
79759
79760
79761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
79762   int jresult ;
79763   int result;
79764
79765   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
79766   jresult = (int)result;
79767   return jresult;
79768 }
79769
79770
79771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
79772   int jresult ;
79773   int result;
79774
79775   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
79776   jresult = (int)result;
79777   return jresult;
79778 }
79779
79780
79781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
79782   int jresult ;
79783   int result;
79784
79785   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
79786   jresult = (int)result;
79787   return jresult;
79788 }
79789
79790
79791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
79792   int jresult ;
79793   int result;
79794
79795   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
79796   jresult = (int)result;
79797   return jresult;
79798 }
79799
79800
79801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
79802   void * jresult ;
79803   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
79804
79805   {
79806     try {
79807       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
79808     } catch (std::out_of_range& e) {
79809       {
79810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79811       };
79812     } catch (std::exception& e) {
79813       {
79814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79815       };
79816     } catch (Dali::DaliException e) {
79817       {
79818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79819       };
79820     } catch (...) {
79821       {
79822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79823       };
79824     }
79825   }
79826
79827   jresult = (void *)result;
79828   return jresult;
79829 }
79830
79831
79832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
79833   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
79834
79835   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
79836   {
79837     try {
79838       delete arg1;
79839     } catch (std::out_of_range& e) {
79840       {
79841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79842       };
79843     } catch (std::exception& e) {
79844       {
79845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79846       };
79847     } catch (Dali::DaliException e) {
79848       {
79849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79850       };
79851     } catch (...) {
79852       {
79853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79854       };
79855     }
79856   }
79857
79858 }
79859
79860
79861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
79862   void * jresult ;
79863   unsigned int arg1 ;
79864   unsigned int arg2 ;
79865   unsigned int arg3 ;
79866   unsigned int arg4 ;
79867   Dali::Toolkit::TableView::CellPosition *result = 0 ;
79868
79869   arg1 = (unsigned int)jarg1;
79870   arg2 = (unsigned int)jarg2;
79871   arg3 = (unsigned int)jarg3;
79872   arg4 = (unsigned int)jarg4;
79873   {
79874     try {
79875       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
79876     } catch (std::out_of_range& e) {
79877       {
79878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79879       };
79880     } catch (std::exception& e) {
79881       {
79882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79883       };
79884     } catch (Dali::DaliException e) {
79885       {
79886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79887       };
79888     } catch (...) {
79889       {
79890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79891       };
79892     }
79893   }
79894
79895   jresult = (void *)result;
79896   return jresult;
79897 }
79898
79899
79900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
79901   void * jresult ;
79902   unsigned int arg1 ;
79903   unsigned int arg2 ;
79904   unsigned int arg3 ;
79905   Dali::Toolkit::TableView::CellPosition *result = 0 ;
79906
79907   arg1 = (unsigned int)jarg1;
79908   arg2 = (unsigned int)jarg2;
79909   arg3 = (unsigned int)jarg3;
79910   {
79911     try {
79912       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
79913     } catch (std::out_of_range& e) {
79914       {
79915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79916       };
79917     } catch (std::exception& e) {
79918       {
79919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79920       };
79921     } catch (Dali::DaliException e) {
79922       {
79923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79924       };
79925     } catch (...) {
79926       {
79927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79928       };
79929     }
79930   }
79931
79932   jresult = (void *)result;
79933   return jresult;
79934 }
79935
79936
79937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
79938   void * jresult ;
79939   unsigned int arg1 ;
79940   unsigned int arg2 ;
79941   Dali::Toolkit::TableView::CellPosition *result = 0 ;
79942
79943   arg1 = (unsigned int)jarg1;
79944   arg2 = (unsigned int)jarg2;
79945   {
79946     try {
79947       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
79948     } catch (std::out_of_range& e) {
79949       {
79950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79951       };
79952     } catch (std::exception& e) {
79953       {
79954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79955       };
79956     } catch (Dali::DaliException e) {
79957       {
79958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79959       };
79960     } catch (...) {
79961       {
79962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79963       };
79964     }
79965   }
79966
79967   jresult = (void *)result;
79968   return jresult;
79969 }
79970
79971
79972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
79973   void * jresult ;
79974   unsigned int arg1 ;
79975   Dali::Toolkit::TableView::CellPosition *result = 0 ;
79976
79977   arg1 = (unsigned int)jarg1;
79978   {
79979     try {
79980       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
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 (Dali::DaliException e) {
79990       {
79991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79992       };
79993     } catch (...) {
79994       {
79995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79996       };
79997     }
79998   }
79999
80000   jresult = (void *)result;
80001   return jresult;
80002 }
80003
80004
80005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
80006   void * jresult ;
80007   Dali::Toolkit::TableView::CellPosition *result = 0 ;
80008
80009   {
80010     try {
80011       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
80012     } catch (std::out_of_range& e) {
80013       {
80014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80015       };
80016     } catch (std::exception& e) {
80017       {
80018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80019       };
80020     } catch (Dali::DaliException e) {
80021       {
80022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80023       };
80024     } catch (...) {
80025       {
80026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80027       };
80028     }
80029   }
80030
80031   jresult = (void *)result;
80032   return jresult;
80033 }
80034
80035
80036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
80037   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
80038   unsigned int arg2 ;
80039
80040   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
80041   arg2 = (unsigned int)jarg2;
80042   if (arg1) (arg1)->rowIndex = arg2;
80043 }
80044
80045
80046 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
80047   unsigned int jresult ;
80048   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
80049   unsigned int result;
80050
80051   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
80052   result = (unsigned int) ((arg1)->rowIndex);
80053   jresult = result;
80054   return jresult;
80055 }
80056
80057
80058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
80059   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
80060   unsigned int arg2 ;
80061
80062   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
80063   arg2 = (unsigned int)jarg2;
80064   if (arg1) (arg1)->columnIndex = arg2;
80065 }
80066
80067
80068 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
80069   unsigned int jresult ;
80070   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
80071   unsigned int result;
80072
80073   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
80074   result = (unsigned int) ((arg1)->columnIndex);
80075   jresult = result;
80076   return jresult;
80077 }
80078
80079
80080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
80081   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
80082   unsigned int arg2 ;
80083
80084   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
80085   arg2 = (unsigned int)jarg2;
80086   if (arg1) (arg1)->rowSpan = arg2;
80087 }
80088
80089
80090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
80091   unsigned int jresult ;
80092   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
80093   unsigned int result;
80094
80095   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
80096   result = (unsigned int) ((arg1)->rowSpan);
80097   jresult = result;
80098   return jresult;
80099 }
80100
80101
80102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
80103   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
80104   unsigned int arg2 ;
80105
80106   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
80107   arg2 = (unsigned int)jarg2;
80108   if (arg1) (arg1)->columnSpan = arg2;
80109 }
80110
80111
80112 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
80113   unsigned int jresult ;
80114   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
80115   unsigned int result;
80116
80117   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
80118   result = (unsigned int) ((arg1)->columnSpan);
80119   jresult = result;
80120   return jresult;
80121 }
80122
80123
80124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
80125   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
80126
80127   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
80128   {
80129     try {
80130       delete arg1;
80131     } catch (std::out_of_range& e) {
80132       {
80133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80134       };
80135     } catch (std::exception& e) {
80136       {
80137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80138       };
80139     } catch (Dali::DaliException e) {
80140       {
80141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80142       };
80143     } catch (...) {
80144       {
80145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80146       };
80147     }
80148   }
80149
80150 }
80151
80152
80153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
80154   void * jresult ;
80155   Dali::Toolkit::TableView *result = 0 ;
80156
80157   {
80158     try {
80159       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
80160     } catch (std::out_of_range& e) {
80161       {
80162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80163       };
80164     } catch (std::exception& e) {
80165       {
80166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80167       };
80168     } catch (Dali::DaliException e) {
80169       {
80170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80171       };
80172     } catch (...) {
80173       {
80174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80175       };
80176     }
80177   }
80178
80179   jresult = (void *)result;
80180   return jresult;
80181 }
80182
80183
80184 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
80185   void * jresult ;
80186   Dali::Toolkit::TableView *arg1 = 0 ;
80187   Dali::Toolkit::TableView *result = 0 ;
80188
80189   arg1 = (Dali::Toolkit::TableView *)jarg1;
80190   if (!arg1) {
80191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
80192     return 0;
80193   }
80194   {
80195     try {
80196       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
80197     } catch (std::out_of_range& e) {
80198       {
80199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80200       };
80201     } catch (std::exception& e) {
80202       {
80203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80204       };
80205     } catch (Dali::DaliException e) {
80206       {
80207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80208       };
80209     } catch (...) {
80210       {
80211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80212       };
80213     }
80214   }
80215
80216   jresult = (void *)result;
80217   return jresult;
80218 }
80219
80220
80221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
80222   void * jresult ;
80223   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80224   Dali::Toolkit::TableView *arg2 = 0 ;
80225   Dali::Toolkit::TableView *result = 0 ;
80226
80227   arg1 = (Dali::Toolkit::TableView *)jarg1;
80228   arg2 = (Dali::Toolkit::TableView *)jarg2;
80229   if (!arg2) {
80230     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
80231     return 0;
80232   }
80233   {
80234     try {
80235       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
80236     } catch (std::out_of_range& e) {
80237       {
80238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80239       };
80240     } catch (std::exception& e) {
80241       {
80242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80243       };
80244     } catch (Dali::DaliException e) {
80245       {
80246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80247       };
80248     } catch (...) {
80249       {
80250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80251       };
80252     }
80253   }
80254
80255   jresult = (void *)result;
80256   return jresult;
80257 }
80258
80259
80260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
80261   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80262
80263   arg1 = (Dali::Toolkit::TableView *)jarg1;
80264   {
80265     try {
80266       delete arg1;
80267     } catch (std::out_of_range& e) {
80268       {
80269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80270       };
80271     } catch (std::exception& e) {
80272       {
80273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80274       };
80275     } catch (Dali::DaliException e) {
80276       {
80277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80278       };
80279     } catch (...) {
80280       {
80281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80282       };
80283     }
80284   }
80285
80286 }
80287
80288
80289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
80290   void * jresult ;
80291   unsigned int arg1 ;
80292   unsigned int arg2 ;
80293   Dali::Toolkit::TableView result;
80294
80295   arg1 = (unsigned int)jarg1;
80296   arg2 = (unsigned int)jarg2;
80297   {
80298     try {
80299       result = Dali::Toolkit::TableView::New(arg1,arg2);
80300     } catch (std::out_of_range& e) {
80301       {
80302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80303       };
80304     } catch (std::exception& e) {
80305       {
80306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80307       };
80308     } catch (Dali::DaliException e) {
80309       {
80310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80311       };
80312     } catch (...) {
80313       {
80314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80315       };
80316     }
80317   }
80318
80319   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
80320   return jresult;
80321 }
80322
80323
80324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
80325   void * jresult ;
80326   Dali::BaseHandle arg1 ;
80327   Dali::BaseHandle *argp1 ;
80328   Dali::Toolkit::TableView 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::TableView::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 (Dali::DaliException e) {
80348       {
80349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80350       };
80351     } catch (...) {
80352       {
80353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80354       };
80355     }
80356   }
80357
80358   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
80359   return jresult;
80360 }
80361
80362
80363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
80364   unsigned int jresult ;
80365   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80366   Dali::Actor arg2 ;
80367   Dali::Toolkit::TableView::CellPosition arg3 ;
80368   Dali::Actor *argp2 ;
80369   Dali::Toolkit::TableView::CellPosition *argp3 ;
80370   bool result;
80371
80372   arg1 = (Dali::Toolkit::TableView *)jarg1;
80373   argp2 = (Dali::Actor *)jarg2;
80374   if (!argp2) {
80375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80376     return 0;
80377   }
80378   arg2 = *argp2;
80379   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
80380   if (!argp3) {
80381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
80382     return 0;
80383   }
80384   arg3 = *argp3;
80385   {
80386     try {
80387       result = (bool)(arg1)->AddChild(arg2,arg3);
80388     } catch (std::out_of_range& e) {
80389       {
80390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80391       };
80392     } catch (std::exception& e) {
80393       {
80394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80395       };
80396     } catch (Dali::DaliException e) {
80397       {
80398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80399       };
80400     } catch (...) {
80401       {
80402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80403       };
80404     }
80405   }
80406
80407   jresult = result;
80408   return jresult;
80409 }
80410
80411
80412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
80413   void * jresult ;
80414   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80415   Dali::Toolkit::TableView::CellPosition arg2 ;
80416   Dali::Toolkit::TableView::CellPosition *argp2 ;
80417   Dali::Actor result;
80418
80419   arg1 = (Dali::Toolkit::TableView *)jarg1;
80420   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
80421   if (!argp2) {
80422     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
80423     return 0;
80424   }
80425   arg2 = *argp2;
80426   {
80427     try {
80428       result = (arg1)->GetChildAt(arg2);
80429     } catch (std::out_of_range& e) {
80430       {
80431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80432       };
80433     } catch (std::exception& e) {
80434       {
80435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80436       };
80437     } catch (Dali::DaliException e) {
80438       {
80439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80440       };
80441     } catch (...) {
80442       {
80443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80444       };
80445     }
80446   }
80447
80448   jresult = new Dali::Actor((const Dali::Actor &)result);
80449   return jresult;
80450 }
80451
80452
80453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
80454   void * jresult ;
80455   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80456   Dali::Toolkit::TableView::CellPosition arg2 ;
80457   Dali::Toolkit::TableView::CellPosition *argp2 ;
80458   Dali::Actor result;
80459
80460   arg1 = (Dali::Toolkit::TableView *)jarg1;
80461   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
80462   if (!argp2) {
80463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
80464     return 0;
80465   }
80466   arg2 = *argp2;
80467   {
80468     try {
80469       result = (arg1)->RemoveChildAt(arg2);
80470     } catch (std::out_of_range& e) {
80471       {
80472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80473       };
80474     } catch (std::exception& e) {
80475       {
80476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80477       };
80478     } catch (Dali::DaliException e) {
80479       {
80480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80481       };
80482     } catch (...) {
80483       {
80484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80485       };
80486     }
80487   }
80488
80489   jresult = new Dali::Actor((const Dali::Actor &)result);
80490   return jresult;
80491 }
80492
80493
80494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
80495   unsigned int jresult ;
80496   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80497   Dali::Actor arg2 ;
80498   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
80499   Dali::Actor *argp2 ;
80500   bool result;
80501
80502   arg1 = (Dali::Toolkit::TableView *)jarg1;
80503   argp2 = (Dali::Actor *)jarg2;
80504   if (!argp2) {
80505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80506     return 0;
80507   }
80508   arg2 = *argp2;
80509   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
80510   if (!arg3) {
80511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
80512     return 0;
80513   }
80514   {
80515     try {
80516       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
80517     } catch (std::out_of_range& e) {
80518       {
80519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80520       };
80521     } catch (std::exception& e) {
80522       {
80523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80524       };
80525     } catch (Dali::DaliException e) {
80526       {
80527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80528       };
80529     } catch (...) {
80530       {
80531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80532       };
80533     }
80534   }
80535
80536   jresult = result;
80537   return jresult;
80538 }
80539
80540
80541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
80542   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80543   unsigned int arg2 ;
80544
80545   arg1 = (Dali::Toolkit::TableView *)jarg1;
80546   arg2 = (unsigned int)jarg2;
80547   {
80548     try {
80549       (arg1)->InsertRow(arg2);
80550     } catch (std::out_of_range& e) {
80551       {
80552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80553       };
80554     } catch (std::exception& e) {
80555       {
80556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80557       };
80558     } catch (Dali::DaliException e) {
80559       {
80560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80561       };
80562     } catch (...) {
80563       {
80564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80565       };
80566     }
80567   }
80568
80569 }
80570
80571
80572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
80573   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80574   unsigned int arg2 ;
80575
80576   arg1 = (Dali::Toolkit::TableView *)jarg1;
80577   arg2 = (unsigned int)jarg2;
80578   {
80579     try {
80580       (arg1)->DeleteRow(arg2);
80581     } catch (std::out_of_range& e) {
80582       {
80583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80584       };
80585     } catch (std::exception& e) {
80586       {
80587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80588       };
80589     } catch (Dali::DaliException e) {
80590       {
80591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80592       };
80593     } catch (...) {
80594       {
80595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80596       };
80597     }
80598   }
80599
80600 }
80601
80602
80603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
80604   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80605   unsigned int arg2 ;
80606   std::vector< Dali::Actor > *arg3 = 0 ;
80607
80608   arg1 = (Dali::Toolkit::TableView *)jarg1;
80609   arg2 = (unsigned int)jarg2;
80610   arg3 = (std::vector< Dali::Actor > *)jarg3;
80611   if (!arg3) {
80612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
80613     return ;
80614   }
80615   {
80616     try {
80617       (arg1)->DeleteRow(arg2,*arg3);
80618     } catch (std::out_of_range& e) {
80619       {
80620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80621       };
80622     } catch (std::exception& e) {
80623       {
80624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80625       };
80626     } catch (Dali::DaliException e) {
80627       {
80628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80629       };
80630     } catch (...) {
80631       {
80632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80633       };
80634     }
80635   }
80636
80637 }
80638
80639
80640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
80641   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80642   unsigned int arg2 ;
80643
80644   arg1 = (Dali::Toolkit::TableView *)jarg1;
80645   arg2 = (unsigned int)jarg2;
80646   {
80647     try {
80648       (arg1)->InsertColumn(arg2);
80649     } catch (std::out_of_range& e) {
80650       {
80651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80652       };
80653     } catch (std::exception& e) {
80654       {
80655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80656       };
80657     } catch (Dali::DaliException e) {
80658       {
80659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80660       };
80661     } catch (...) {
80662       {
80663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80664       };
80665     }
80666   }
80667
80668 }
80669
80670
80671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
80672   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80673   unsigned int arg2 ;
80674
80675   arg1 = (Dali::Toolkit::TableView *)jarg1;
80676   arg2 = (unsigned int)jarg2;
80677   {
80678     try {
80679       (arg1)->DeleteColumn(arg2);
80680     } catch (std::out_of_range& e) {
80681       {
80682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80683       };
80684     } catch (std::exception& e) {
80685       {
80686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80687       };
80688     } catch (Dali::DaliException e) {
80689       {
80690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80691       };
80692     } catch (...) {
80693       {
80694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80695       };
80696     }
80697   }
80698
80699 }
80700
80701
80702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
80703   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80704   unsigned int arg2 ;
80705   std::vector< Dali::Actor > *arg3 = 0 ;
80706
80707   arg1 = (Dali::Toolkit::TableView *)jarg1;
80708   arg2 = (unsigned int)jarg2;
80709   arg3 = (std::vector< Dali::Actor > *)jarg3;
80710   if (!arg3) {
80711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
80712     return ;
80713   }
80714   {
80715     try {
80716       (arg1)->DeleteColumn(arg2,*arg3);
80717     } catch (std::out_of_range& e) {
80718       {
80719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80720       };
80721     } catch (std::exception& e) {
80722       {
80723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80724       };
80725     } catch (Dali::DaliException e) {
80726       {
80727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80728       };
80729     } catch (...) {
80730       {
80731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80732       };
80733     }
80734   }
80735
80736 }
80737
80738
80739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
80740   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80741   unsigned int arg2 ;
80742   unsigned int arg3 ;
80743
80744   arg1 = (Dali::Toolkit::TableView *)jarg1;
80745   arg2 = (unsigned int)jarg2;
80746   arg3 = (unsigned int)jarg3;
80747   {
80748     try {
80749       (arg1)->Resize(arg2,arg3);
80750     } catch (std::out_of_range& e) {
80751       {
80752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80753       };
80754     } catch (std::exception& e) {
80755       {
80756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80757       };
80758     } catch (Dali::DaliException e) {
80759       {
80760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80761       };
80762     } catch (...) {
80763       {
80764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80765       };
80766     }
80767   }
80768
80769 }
80770
80771
80772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
80773   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80774   unsigned int arg2 ;
80775   unsigned int arg3 ;
80776   std::vector< Dali::Actor > *arg4 = 0 ;
80777
80778   arg1 = (Dali::Toolkit::TableView *)jarg1;
80779   arg2 = (unsigned int)jarg2;
80780   arg3 = (unsigned int)jarg3;
80781   arg4 = (std::vector< Dali::Actor > *)jarg4;
80782   if (!arg4) {
80783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
80784     return ;
80785   }
80786   {
80787     try {
80788       (arg1)->Resize(arg2,arg3,*arg4);
80789     } catch (std::out_of_range& e) {
80790       {
80791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80792       };
80793     } catch (std::exception& e) {
80794       {
80795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80796       };
80797     } catch (Dali::DaliException e) {
80798       {
80799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80800       };
80801     } catch (...) {
80802       {
80803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80804       };
80805     }
80806   }
80807
80808 }
80809
80810
80811 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
80812   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80813   Dali::Size arg2 ;
80814   Dali::Size *argp2 ;
80815
80816   arg1 = (Dali::Toolkit::TableView *)jarg1;
80817   argp2 = (Dali::Size *)jarg2;
80818   if (!argp2) {
80819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
80820     return ;
80821   }
80822   arg2 = *argp2;
80823   {
80824     try {
80825       (arg1)->SetCellPadding(arg2);
80826     } catch (std::out_of_range& e) {
80827       {
80828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80829       };
80830     } catch (std::exception& e) {
80831       {
80832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80833       };
80834     } catch (Dali::DaliException e) {
80835       {
80836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80837       };
80838     } catch (...) {
80839       {
80840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80841       };
80842     }
80843   }
80844
80845 }
80846
80847
80848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
80849   void * jresult ;
80850   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80851   Dali::Size result;
80852
80853   arg1 = (Dali::Toolkit::TableView *)jarg1;
80854   {
80855     try {
80856       result = (arg1)->GetCellPadding();
80857     } catch (std::out_of_range& e) {
80858       {
80859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80860       };
80861     } catch (std::exception& e) {
80862       {
80863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80864       };
80865     } catch (Dali::DaliException e) {
80866       {
80867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80868       };
80869     } catch (...) {
80870       {
80871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80872       };
80873     }
80874   }
80875
80876   jresult = new Dali::Size((const Dali::Size &)result);
80877   return jresult;
80878 }
80879
80880
80881 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
80882   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80883   unsigned int arg2 ;
80884
80885   arg1 = (Dali::Toolkit::TableView *)jarg1;
80886   arg2 = (unsigned int)jarg2;
80887   {
80888     try {
80889       (arg1)->SetFitHeight(arg2);
80890     } catch (std::out_of_range& e) {
80891       {
80892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80893       };
80894     } catch (std::exception& e) {
80895       {
80896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80897       };
80898     } catch (Dali::DaliException e) {
80899       {
80900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80901       };
80902     } catch (...) {
80903       {
80904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80905       };
80906     }
80907   }
80908
80909 }
80910
80911
80912 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
80913   unsigned int jresult ;
80914   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80915   unsigned int arg2 ;
80916   bool result;
80917
80918   arg1 = (Dali::Toolkit::TableView *)jarg1;
80919   arg2 = (unsigned int)jarg2;
80920   {
80921     try {
80922       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
80923     } catch (std::out_of_range& e) {
80924       {
80925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80926       };
80927     } catch (std::exception& e) {
80928       {
80929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80930       };
80931     } catch (Dali::DaliException e) {
80932       {
80933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80934       };
80935     } catch (...) {
80936       {
80937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80938       };
80939     }
80940   }
80941
80942   jresult = result;
80943   return jresult;
80944 }
80945
80946
80947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
80948   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80949   unsigned int arg2 ;
80950
80951   arg1 = (Dali::Toolkit::TableView *)jarg1;
80952   arg2 = (unsigned int)jarg2;
80953   {
80954     try {
80955       (arg1)->SetFitWidth(arg2);
80956     } catch (std::out_of_range& e) {
80957       {
80958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80959       };
80960     } catch (std::exception& e) {
80961       {
80962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80963       };
80964     } catch (Dali::DaliException e) {
80965       {
80966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80967       };
80968     } catch (...) {
80969       {
80970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80971       };
80972     }
80973   }
80974
80975 }
80976
80977
80978 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
80979   unsigned int jresult ;
80980   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
80981   unsigned int arg2 ;
80982   bool result;
80983
80984   arg1 = (Dali::Toolkit::TableView *)jarg1;
80985   arg2 = (unsigned int)jarg2;
80986   {
80987     try {
80988       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
80989     } catch (std::out_of_range& e) {
80990       {
80991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80992       };
80993     } catch (std::exception& e) {
80994       {
80995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80996       };
80997     } catch (Dali::DaliException e) {
80998       {
80999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81000       };
81001     } catch (...) {
81002       {
81003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81004       };
81005     }
81006   }
81007
81008   jresult = result;
81009   return jresult;
81010 }
81011
81012
81013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
81014   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81015   unsigned int arg2 ;
81016   float arg3 ;
81017
81018   arg1 = (Dali::Toolkit::TableView *)jarg1;
81019   arg2 = (unsigned int)jarg2;
81020   arg3 = (float)jarg3;
81021   {
81022     try {
81023       (arg1)->SetFixedHeight(arg2,arg3);
81024     } catch (std::out_of_range& e) {
81025       {
81026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81027       };
81028     } catch (std::exception& e) {
81029       {
81030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81031       };
81032     } catch (Dali::DaliException e) {
81033       {
81034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81035       };
81036     } catch (...) {
81037       {
81038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81039       };
81040     }
81041   }
81042
81043 }
81044
81045
81046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
81047   float jresult ;
81048   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81049   unsigned int arg2 ;
81050   float result;
81051
81052   arg1 = (Dali::Toolkit::TableView *)jarg1;
81053   arg2 = (unsigned int)jarg2;
81054   {
81055     try {
81056       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
81057     } catch (std::out_of_range& e) {
81058       {
81059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81060       };
81061     } catch (std::exception& e) {
81062       {
81063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81064       };
81065     } catch (Dali::DaliException e) {
81066       {
81067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81068       };
81069     } catch (...) {
81070       {
81071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81072       };
81073     }
81074   }
81075
81076   jresult = result;
81077   return jresult;
81078 }
81079
81080
81081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
81082   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81083   unsigned int arg2 ;
81084   float arg3 ;
81085
81086   arg1 = (Dali::Toolkit::TableView *)jarg1;
81087   arg2 = (unsigned int)jarg2;
81088   arg3 = (float)jarg3;
81089   {
81090     try {
81091       (arg1)->SetRelativeHeight(arg2,arg3);
81092     } catch (std::out_of_range& e) {
81093       {
81094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81095       };
81096     } catch (std::exception& e) {
81097       {
81098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81099       };
81100     } catch (Dali::DaliException e) {
81101       {
81102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81103       };
81104     } catch (...) {
81105       {
81106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81107       };
81108     }
81109   }
81110
81111 }
81112
81113
81114 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
81115   float jresult ;
81116   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81117   unsigned int arg2 ;
81118   float result;
81119
81120   arg1 = (Dali::Toolkit::TableView *)jarg1;
81121   arg2 = (unsigned int)jarg2;
81122   {
81123     try {
81124       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
81125     } catch (std::out_of_range& e) {
81126       {
81127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81128       };
81129     } catch (std::exception& e) {
81130       {
81131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81132       };
81133     } catch (Dali::DaliException e) {
81134       {
81135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81136       };
81137     } catch (...) {
81138       {
81139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81140       };
81141     }
81142   }
81143
81144   jresult = result;
81145   return jresult;
81146 }
81147
81148
81149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
81150   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81151   unsigned int arg2 ;
81152   float arg3 ;
81153
81154   arg1 = (Dali::Toolkit::TableView *)jarg1;
81155   arg2 = (unsigned int)jarg2;
81156   arg3 = (float)jarg3;
81157   {
81158     try {
81159       (arg1)->SetFixedWidth(arg2,arg3);
81160     } catch (std::out_of_range& e) {
81161       {
81162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81163       };
81164     } catch (std::exception& e) {
81165       {
81166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81167       };
81168     } catch (Dali::DaliException e) {
81169       {
81170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81171       };
81172     } catch (...) {
81173       {
81174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81175       };
81176     }
81177   }
81178
81179 }
81180
81181
81182 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
81183   float jresult ;
81184   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81185   unsigned int arg2 ;
81186   float result;
81187
81188   arg1 = (Dali::Toolkit::TableView *)jarg1;
81189   arg2 = (unsigned int)jarg2;
81190   {
81191     try {
81192       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
81193     } catch (std::out_of_range& e) {
81194       {
81195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81196       };
81197     } catch (std::exception& e) {
81198       {
81199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81200       };
81201     } catch (Dali::DaliException e) {
81202       {
81203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81204       };
81205     } catch (...) {
81206       {
81207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81208       };
81209     }
81210   }
81211
81212   jresult = result;
81213   return jresult;
81214 }
81215
81216
81217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
81218   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81219   unsigned int arg2 ;
81220   float arg3 ;
81221
81222   arg1 = (Dali::Toolkit::TableView *)jarg1;
81223   arg2 = (unsigned int)jarg2;
81224   arg3 = (float)jarg3;
81225   {
81226     try {
81227       (arg1)->SetRelativeWidth(arg2,arg3);
81228     } catch (std::out_of_range& e) {
81229       {
81230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81231       };
81232     } catch (std::exception& e) {
81233       {
81234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81235       };
81236     } catch (Dali::DaliException e) {
81237       {
81238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81239       };
81240     } catch (...) {
81241       {
81242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81243       };
81244     }
81245   }
81246
81247 }
81248
81249
81250 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
81251   float jresult ;
81252   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81253   unsigned int arg2 ;
81254   float result;
81255
81256   arg1 = (Dali::Toolkit::TableView *)jarg1;
81257   arg2 = (unsigned int)jarg2;
81258   {
81259     try {
81260       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
81261     } catch (std::out_of_range& e) {
81262       {
81263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81264       };
81265     } catch (std::exception& e) {
81266       {
81267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81268       };
81269     } catch (Dali::DaliException e) {
81270       {
81271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81272       };
81273     } catch (...) {
81274       {
81275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81276       };
81277     }
81278   }
81279
81280   jresult = result;
81281   return jresult;
81282 }
81283
81284
81285 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
81286   unsigned int jresult ;
81287   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81288   unsigned int result;
81289
81290   arg1 = (Dali::Toolkit::TableView *)jarg1;
81291   {
81292     try {
81293       result = (unsigned int)(arg1)->GetRows();
81294     } catch (std::out_of_range& e) {
81295       {
81296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81297       };
81298     } catch (std::exception& e) {
81299       {
81300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81301       };
81302     } catch (Dali::DaliException e) {
81303       {
81304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81305       };
81306     } catch (...) {
81307       {
81308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81309       };
81310     }
81311   }
81312
81313   jresult = result;
81314   return jresult;
81315 }
81316
81317
81318 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
81319   unsigned int jresult ;
81320   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81321   unsigned int result;
81322
81323   arg1 = (Dali::Toolkit::TableView *)jarg1;
81324   {
81325     try {
81326       result = (unsigned int)(arg1)->GetColumns();
81327     } catch (std::out_of_range& e) {
81328       {
81329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81330       };
81331     } catch (std::exception& e) {
81332       {
81333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81334       };
81335     } catch (Dali::DaliException e) {
81336       {
81337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81338       };
81339     } catch (...) {
81340       {
81341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81342       };
81343     }
81344   }
81345
81346   jresult = result;
81347   return jresult;
81348 }
81349
81350
81351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
81352   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
81353   Dali::Toolkit::TableView::CellPosition arg2 ;
81354   Dali::HorizontalAlignment::Type arg3 ;
81355   Dali::VerticalAlignment::Type arg4 ;
81356   Dali::Toolkit::TableView::CellPosition *argp2 ;
81357
81358   arg1 = (Dali::Toolkit::TableView *)jarg1;
81359   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
81360   if (!argp2) {
81361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
81362     return ;
81363   }
81364   arg2 = *argp2;
81365   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
81366   arg4 = (Dali::VerticalAlignment::Type)jarg4;
81367   {
81368     try {
81369       (arg1)->SetCellAlignment(arg2,arg3,arg4);
81370     } catch (std::out_of_range& e) {
81371       {
81372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81373       };
81374     } catch (std::exception& e) {
81375       {
81376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81377       };
81378     } catch (Dali::DaliException e) {
81379       {
81380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81381       };
81382     } catch (...) {
81383       {
81384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81385       };
81386     }
81387   }
81388
81389 }
81390
81391
81392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
81393   unsigned int jresult ;
81394   unsigned int result;
81395
81396   result = (unsigned int)(unsigned int)Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
81397   jresult = result;
81398   return jresult;
81399 }
81400
81401
81402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_RENDERING_BACKEND_get() {
81403   int jresult ;
81404   int result;
81405
81406   result = (int)Dali::Toolkit::TextLabel::Property::RENDERING_BACKEND;
81407   jresult = (int)result;
81408   return jresult;
81409 }
81410
81411
81412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
81413   int jresult ;
81414   int result;
81415
81416   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
81417   jresult = (int)result;
81418   return jresult;
81419 }
81420
81421
81422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
81423   int jresult ;
81424   int result;
81425
81426   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
81427   jresult = (int)result;
81428   return jresult;
81429 }
81430
81431
81432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
81433   int jresult ;
81434   int result;
81435
81436   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
81437   jresult = (int)result;
81438   return jresult;
81439 }
81440
81441
81442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
81443   int jresult ;
81444   int result;
81445
81446   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
81447   jresult = (int)result;
81448   return jresult;
81449 }
81450
81451
81452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
81453   int jresult ;
81454   int result;
81455
81456   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
81457   jresult = (int)result;
81458   return jresult;
81459 }
81460
81461
81462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
81463   int jresult ;
81464   int result;
81465
81466   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
81467   jresult = (int)result;
81468   return jresult;
81469 }
81470
81471
81472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
81473   int jresult ;
81474   int result;
81475
81476   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
81477   jresult = (int)result;
81478   return jresult;
81479 }
81480
81481
81482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
81483   int jresult ;
81484   int result;
81485
81486   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
81487   jresult = (int)result;
81488   return jresult;
81489 }
81490
81491
81492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
81493   int jresult ;
81494   int result;
81495
81496   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
81497   jresult = (int)result;
81498   return jresult;
81499 }
81500
81501
81502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
81503   int jresult ;
81504   int result;
81505
81506   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
81507   jresult = (int)result;
81508   return jresult;
81509 }
81510
81511
81512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
81513   int jresult ;
81514   int result;
81515
81516   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
81517   jresult = (int)result;
81518   return jresult;
81519 }
81520
81521
81522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
81523   int jresult ;
81524   int result;
81525
81526   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
81527   jresult = (int)result;
81528   return jresult;
81529 }
81530
81531
81532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
81533   int jresult ;
81534   int result;
81535
81536   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
81537   jresult = (int)result;
81538   return jresult;
81539 }
81540
81541
81542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
81543   int jresult ;
81544   int result;
81545
81546   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
81547   jresult = (int)result;
81548   return jresult;
81549 }
81550
81551
81552 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
81553   int jresult ;
81554   int result;
81555
81556   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
81557   jresult = (int)result;
81558   return jresult;
81559 }
81560
81561
81562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
81563   int jresult ;
81564   int result;
81565
81566   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
81567   jresult = (int)result;
81568   return jresult;
81569 }
81570
81571
81572 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
81573   int jresult ;
81574   int result;
81575
81576   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
81577   jresult = (int)result;
81578   return jresult;
81579 }
81580
81581
81582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
81583   int jresult ;
81584   int result;
81585
81586   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
81587   jresult = (int)result;
81588   return jresult;
81589 }
81590
81591
81592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
81593   void * jresult ;
81594   Dali::Toolkit::TextLabel::Property *result = 0 ;
81595
81596   {
81597     try {
81598       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
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 (Dali::DaliException e) {
81608       {
81609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81610       };
81611     } catch (...) {
81612       {
81613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81614       };
81615     }
81616   }
81617
81618   jresult = (void *)result;
81619   return jresult;
81620 }
81621
81622
81623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
81624   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
81625
81626   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
81627   {
81628     try {
81629       delete arg1;
81630     } catch (std::out_of_range& e) {
81631       {
81632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81633       };
81634     } catch (std::exception& e) {
81635       {
81636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81637       };
81638     } catch (Dali::DaliException e) {
81639       {
81640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81641       };
81642     } catch (...) {
81643       {
81644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81645       };
81646     }
81647   }
81648
81649 }
81650
81651
81652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
81653   void * jresult ;
81654   Dali::Toolkit::TextLabel result;
81655
81656   {
81657     try {
81658       result = Dali::Toolkit::TextLabel::New();
81659     } catch (std::out_of_range& e) {
81660       {
81661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81662       };
81663     } catch (std::exception& e) {
81664       {
81665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81666       };
81667     } catch (Dali::DaliException e) {
81668       {
81669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81670       };
81671     } catch (...) {
81672       {
81673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81674       };
81675     }
81676   }
81677
81678   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
81679   return jresult;
81680 }
81681
81682
81683 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
81684   void * jresult ;
81685   std::string *arg1 = 0 ;
81686   Dali::Toolkit::TextLabel result;
81687
81688   if (!jarg1) {
81689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81690     return 0;
81691   }
81692   std::string arg1_str(jarg1);
81693   arg1 = &arg1_str;
81694   {
81695     try {
81696       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
81697     } catch (std::out_of_range& e) {
81698       {
81699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81700       };
81701     } catch (std::exception& e) {
81702       {
81703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81704       };
81705     } catch (Dali::DaliException e) {
81706       {
81707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81708       };
81709     } catch (...) {
81710       {
81711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81712       };
81713     }
81714   }
81715
81716   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
81717
81718   //argout typemap for const std::string&
81719
81720   return jresult;
81721 }
81722
81723
81724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
81725   void * jresult ;
81726   Dali::Toolkit::TextLabel *result = 0 ;
81727
81728   {
81729     try {
81730       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
81731     } catch (std::out_of_range& e) {
81732       {
81733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81734       };
81735     } catch (std::exception& e) {
81736       {
81737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81738       };
81739     } catch (Dali::DaliException e) {
81740       {
81741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81742       };
81743     } catch (...) {
81744       {
81745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81746       };
81747     }
81748   }
81749
81750   jresult = (void *)result;
81751   return jresult;
81752 }
81753
81754
81755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
81756   void * jresult ;
81757   Dali::Toolkit::TextLabel *arg1 = 0 ;
81758   Dali::Toolkit::TextLabel *result = 0 ;
81759
81760   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
81761   if (!arg1) {
81762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
81763     return 0;
81764   }
81765   {
81766     try {
81767       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
81768     } catch (std::out_of_range& e) {
81769       {
81770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81771       };
81772     } catch (std::exception& e) {
81773       {
81774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81775       };
81776     } catch (Dali::DaliException e) {
81777       {
81778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81779       };
81780     } catch (...) {
81781       {
81782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81783       };
81784     }
81785   }
81786
81787   jresult = (void *)result;
81788   return jresult;
81789 }
81790
81791
81792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
81793   void * jresult ;
81794   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
81795   Dali::Toolkit::TextLabel *arg2 = 0 ;
81796   Dali::Toolkit::TextLabel *result = 0 ;
81797
81798   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
81799   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
81800   if (!arg2) {
81801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
81802     return 0;
81803   }
81804   {
81805     try {
81806       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
81807     } catch (std::out_of_range& e) {
81808       {
81809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81810       };
81811     } catch (std::exception& e) {
81812       {
81813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81814       };
81815     } catch (Dali::DaliException e) {
81816       {
81817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81818       };
81819     } catch (...) {
81820       {
81821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81822       };
81823     }
81824   }
81825
81826   jresult = (void *)result;
81827   return jresult;
81828 }
81829
81830
81831 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
81832   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
81833
81834   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
81835   {
81836     try {
81837       delete arg1;
81838     } catch (std::out_of_range& e) {
81839       {
81840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81841       };
81842     } catch (std::exception& e) {
81843       {
81844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81845       };
81846     } catch (Dali::DaliException e) {
81847       {
81848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81849       };
81850     } catch (...) {
81851       {
81852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81853       };
81854     }
81855   }
81856
81857 }
81858
81859
81860 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
81861   void * jresult ;
81862   Dali::BaseHandle arg1 ;
81863   Dali::BaseHandle *argp1 ;
81864   Dali::Toolkit::TextLabel result;
81865
81866   argp1 = (Dali::BaseHandle *)jarg1;
81867   if (!argp1) {
81868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81869     return 0;
81870   }
81871   arg1 = *argp1;
81872   {
81873     try {
81874       result = Dali::Toolkit::TextLabel::DownCast(arg1);
81875     } catch (std::out_of_range& e) {
81876       {
81877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81878       };
81879     } catch (std::exception& e) {
81880       {
81881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81882       };
81883     } catch (Dali::DaliException e) {
81884       {
81885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81886       };
81887     } catch (...) {
81888       {
81889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81890       };
81891     }
81892   }
81893
81894   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
81895   return jresult;
81896 }
81897
81898
81899 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
81900   void * jresult ;
81901   Dali::Toolkit::AccessibilityManager *result = 0 ;
81902
81903   {
81904     try {
81905       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
81906     } catch (std::out_of_range& e) {
81907       {
81908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81909       };
81910     } catch (std::exception& e) {
81911       {
81912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81913       };
81914     } catch (Dali::DaliException e) {
81915       {
81916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81917       };
81918     } catch (...) {
81919       {
81920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81921       };
81922     }
81923   }
81924
81925   jresult = (void *)result;
81926   return jresult;
81927 }
81928
81929
81930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
81931   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81932
81933   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81934   {
81935     try {
81936       delete arg1;
81937     } catch (std::out_of_range& e) {
81938       {
81939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81940       };
81941     } catch (std::exception& e) {
81942       {
81943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81944       };
81945     } catch (Dali::DaliException e) {
81946       {
81947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81948       };
81949     } catch (...) {
81950       {
81951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81952       };
81953     }
81954   }
81955
81956 }
81957
81958
81959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
81960   void * jresult ;
81961   Dali::Toolkit::AccessibilityManager result;
81962
81963   {
81964     try {
81965       result = Dali::Toolkit::AccessibilityManager::Get();
81966     } catch (std::out_of_range& e) {
81967       {
81968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81969       };
81970     } catch (std::exception& e) {
81971       {
81972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81973       };
81974     } catch (Dali::DaliException e) {
81975       {
81976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81977       };
81978     } catch (...) {
81979       {
81980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81981       };
81982     }
81983   }
81984
81985   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
81986   return jresult;
81987 }
81988
81989
81990 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
81991   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81992   Dali::Actor arg2 ;
81993   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
81994   std::string *arg4 = 0 ;
81995   Dali::Actor *argp2 ;
81996
81997   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81998   argp2 = (Dali::Actor *)jarg2;
81999   if (!argp2) {
82000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82001     return ;
82002   }
82003   arg2 = *argp2;
82004   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
82005   if (!jarg4) {
82006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82007     return ;
82008   }
82009   std::string arg4_str(jarg4);
82010   arg4 = &arg4_str;
82011   {
82012     try {
82013       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
82014     } catch (std::out_of_range& e) {
82015       {
82016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82017       };
82018     } catch (std::exception& e) {
82019       {
82020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82021       };
82022     } catch (Dali::DaliException e) {
82023       {
82024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82025       };
82026     } catch (...) {
82027       {
82028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82029       };
82030     }
82031   }
82032
82033
82034   //argout typemap for const std::string&
82035
82036 }
82037
82038
82039 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
82040   char * jresult ;
82041   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82042   Dali::Actor arg2 ;
82043   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
82044   Dali::Actor *argp2 ;
82045   std::string result;
82046
82047   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82048   argp2 = (Dali::Actor *)jarg2;
82049   if (!argp2) {
82050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82051     return 0;
82052   }
82053   arg2 = *argp2;
82054   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
82055   {
82056     try {
82057       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
82058     } catch (std::out_of_range& e) {
82059       {
82060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82061       };
82062     } catch (std::exception& e) {
82063       {
82064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82065       };
82066     } catch (Dali::DaliException e) {
82067       {
82068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82069       };
82070     } catch (...) {
82071       {
82072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82073       };
82074     }
82075   }
82076
82077   jresult = SWIG_csharp_string_callback((&result)->c_str());
82078   return jresult;
82079 }
82080
82081
82082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
82083   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82084   Dali::Actor arg2 ;
82085   unsigned int arg3 ;
82086   Dali::Actor *argp2 ;
82087
82088   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82089   argp2 = (Dali::Actor *)jarg2;
82090   if (!argp2) {
82091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82092     return ;
82093   }
82094   arg2 = *argp2;
82095   arg3 = (unsigned int)jarg3;
82096   {
82097     try {
82098       (arg1)->SetFocusOrder(arg2,arg3);
82099     } catch (std::out_of_range& e) {
82100       {
82101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82102       };
82103     } catch (std::exception& e) {
82104       {
82105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82106       };
82107     } catch (Dali::DaliException e) {
82108       {
82109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82110       };
82111     } catch (...) {
82112       {
82113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82114       };
82115     }
82116   }
82117
82118 }
82119
82120
82121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
82122   unsigned int jresult ;
82123   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82124   Dali::Actor arg2 ;
82125   Dali::Actor *argp2 ;
82126   unsigned int result;
82127
82128   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82129   argp2 = (Dali::Actor *)jarg2;
82130   if (!argp2) {
82131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82132     return 0;
82133   }
82134   arg2 = *argp2;
82135   {
82136     try {
82137       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
82138     } catch (std::out_of_range& e) {
82139       {
82140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82141       };
82142     } catch (std::exception& e) {
82143       {
82144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82145       };
82146     } catch (Dali::DaliException e) {
82147       {
82148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82149       };
82150     } catch (...) {
82151       {
82152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82153       };
82154     }
82155   }
82156
82157   jresult = result;
82158   return jresult;
82159 }
82160
82161
82162 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
82163   unsigned int jresult ;
82164   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82165   unsigned int result;
82166
82167   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82168   {
82169     try {
82170       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
82171     } catch (std::out_of_range& e) {
82172       {
82173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82174       };
82175     } catch (std::exception& e) {
82176       {
82177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82178       };
82179     } catch (Dali::DaliException e) {
82180       {
82181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82182       };
82183     } catch (...) {
82184       {
82185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82186       };
82187     }
82188   }
82189
82190   jresult = result;
82191   return jresult;
82192 }
82193
82194
82195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
82196   void * jresult ;
82197   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82198   unsigned int arg2 ;
82199   Dali::Actor result;
82200
82201   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82202   arg2 = (unsigned int)jarg2;
82203   {
82204     try {
82205       result = (arg1)->GetActorByFocusOrder(arg2);
82206     } catch (std::out_of_range& e) {
82207       {
82208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82209       };
82210     } catch (std::exception& e) {
82211       {
82212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82213       };
82214     } catch (Dali::DaliException e) {
82215       {
82216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82217       };
82218     } catch (...) {
82219       {
82220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82221       };
82222     }
82223   }
82224
82225   jresult = new Dali::Actor((const Dali::Actor &)result);
82226   return jresult;
82227 }
82228
82229
82230 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
82231   unsigned int jresult ;
82232   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82233   Dali::Actor arg2 ;
82234   Dali::Actor *argp2 ;
82235   bool result;
82236
82237   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82238   argp2 = (Dali::Actor *)jarg2;
82239   if (!argp2) {
82240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82241     return 0;
82242   }
82243   arg2 = *argp2;
82244   {
82245     try {
82246       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
82247     } catch (std::out_of_range& e) {
82248       {
82249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82250       };
82251     } catch (std::exception& e) {
82252       {
82253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82254       };
82255     } catch (Dali::DaliException e) {
82256       {
82257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82258       };
82259     } catch (...) {
82260       {
82261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82262       };
82263     }
82264   }
82265
82266   jresult = result;
82267   return jresult;
82268 }
82269
82270
82271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
82272   void * jresult ;
82273   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82274   Dali::Actor result;
82275
82276   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82277   {
82278     try {
82279       result = (arg1)->GetCurrentFocusActor();
82280     } catch (std::out_of_range& e) {
82281       {
82282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82283       };
82284     } catch (std::exception& e) {
82285       {
82286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82287       };
82288     } catch (Dali::DaliException e) {
82289       {
82290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82291       };
82292     } catch (...) {
82293       {
82294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82295       };
82296     }
82297   }
82298
82299   jresult = new Dali::Actor((const Dali::Actor &)result);
82300   return jresult;
82301 }
82302
82303
82304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
82305   void * jresult ;
82306   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82307   Dali::Actor result;
82308
82309   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82310   {
82311     try {
82312       result = (arg1)->GetCurrentFocusGroup();
82313     } catch (std::out_of_range& e) {
82314       {
82315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82316       };
82317     } catch (std::exception& e) {
82318       {
82319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82320       };
82321     } catch (Dali::DaliException e) {
82322       {
82323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82324       };
82325     } catch (...) {
82326       {
82327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82328       };
82329     }
82330   }
82331
82332   jresult = new Dali::Actor((const Dali::Actor &)result);
82333   return jresult;
82334 }
82335
82336
82337 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
82338   unsigned int jresult ;
82339   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82340   unsigned int result;
82341
82342   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82343   {
82344     try {
82345       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
82346     } catch (std::out_of_range& e) {
82347       {
82348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82349       };
82350     } catch (std::exception& e) {
82351       {
82352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82353       };
82354     } catch (Dali::DaliException e) {
82355       {
82356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82357       };
82358     } catch (...) {
82359       {
82360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82361       };
82362     }
82363   }
82364
82365   jresult = result;
82366   return jresult;
82367 }
82368
82369
82370 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
82371   unsigned int jresult ;
82372   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82373   bool result;
82374
82375   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82376   {
82377     try {
82378       result = (bool)(arg1)->MoveFocusForward();
82379     } catch (std::out_of_range& e) {
82380       {
82381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82382       };
82383     } catch (std::exception& e) {
82384       {
82385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82386       };
82387     } catch (Dali::DaliException e) {
82388       {
82389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82390       };
82391     } catch (...) {
82392       {
82393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82394       };
82395     }
82396   }
82397
82398   jresult = result;
82399   return jresult;
82400 }
82401
82402
82403 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
82404   unsigned int jresult ;
82405   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82406   bool result;
82407
82408   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82409   {
82410     try {
82411       result = (bool)(arg1)->MoveFocusBackward();
82412     } catch (std::out_of_range& e) {
82413       {
82414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82415       };
82416     } catch (std::exception& e) {
82417       {
82418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82419       };
82420     } catch (Dali::DaliException e) {
82421       {
82422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82423       };
82424     } catch (...) {
82425       {
82426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82427       };
82428     }
82429   }
82430
82431   jresult = result;
82432   return jresult;
82433 }
82434
82435
82436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
82437   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82438
82439   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82440   {
82441     try {
82442       (arg1)->ClearFocus();
82443     } catch (std::out_of_range& e) {
82444       {
82445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82446       };
82447     } catch (std::exception& e) {
82448       {
82449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82450       };
82451     } catch (Dali::DaliException e) {
82452       {
82453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82454       };
82455     } catch (...) {
82456       {
82457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82458       };
82459     }
82460   }
82461
82462 }
82463
82464
82465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
82466   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82467
82468   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82469   {
82470     try {
82471       (arg1)->Reset();
82472     } catch (std::out_of_range& e) {
82473       {
82474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82475       };
82476     } catch (std::exception& e) {
82477       {
82478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82479       };
82480     } catch (Dali::DaliException e) {
82481       {
82482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82483       };
82484     } catch (...) {
82485       {
82486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82487       };
82488     }
82489   }
82490
82491 }
82492
82493
82494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
82495   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82496   Dali::Actor arg2 ;
82497   bool arg3 ;
82498   Dali::Actor *argp2 ;
82499
82500   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82501   argp2 = (Dali::Actor *)jarg2;
82502   if (!argp2) {
82503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82504     return ;
82505   }
82506   arg2 = *argp2;
82507   arg3 = jarg3 ? true : false;
82508   {
82509     try {
82510       (arg1)->SetFocusGroup(arg2,arg3);
82511     } catch (std::out_of_range& e) {
82512       {
82513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82514       };
82515     } catch (std::exception& e) {
82516       {
82517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82518       };
82519     } catch (Dali::DaliException e) {
82520       {
82521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82522       };
82523     } catch (...) {
82524       {
82525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82526       };
82527     }
82528   }
82529
82530 }
82531
82532
82533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
82534   unsigned int jresult ;
82535   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82536   Dali::Actor arg2 ;
82537   Dali::Actor *argp2 ;
82538   bool result;
82539
82540   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82541   argp2 = (Dali::Actor *)jarg2;
82542   if (!argp2) {
82543     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82544     return 0;
82545   }
82546   arg2 = *argp2;
82547   {
82548     try {
82549       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
82550     } catch (std::out_of_range& e) {
82551       {
82552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82553       };
82554     } catch (std::exception& e) {
82555       {
82556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82557       };
82558     } catch (Dali::DaliException e) {
82559       {
82560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82561       };
82562     } catch (...) {
82563       {
82564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82565       };
82566     }
82567   }
82568
82569   jresult = result;
82570   return jresult;
82571 }
82572
82573
82574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
82575   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82576   bool arg2 ;
82577
82578   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82579   arg2 = jarg2 ? true : false;
82580   {
82581     try {
82582       (arg1)->SetGroupMode(arg2);
82583     } catch (std::out_of_range& e) {
82584       {
82585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82586       };
82587     } catch (std::exception& e) {
82588       {
82589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82590       };
82591     } catch (Dali::DaliException e) {
82592       {
82593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82594       };
82595     } catch (...) {
82596       {
82597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82598       };
82599     }
82600   }
82601
82602 }
82603
82604
82605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
82606   unsigned int jresult ;
82607   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82608   bool result;
82609
82610   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82611   {
82612     try {
82613       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
82614     } catch (std::out_of_range& e) {
82615       {
82616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82617       };
82618     } catch (std::exception& e) {
82619       {
82620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82621       };
82622     } catch (Dali::DaliException e) {
82623       {
82624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82625       };
82626     } catch (...) {
82627       {
82628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82629       };
82630     }
82631   }
82632
82633   jresult = result;
82634   return jresult;
82635 }
82636
82637
82638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
82639   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82640   bool arg2 ;
82641
82642   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82643   arg2 = jarg2 ? true : false;
82644   {
82645     try {
82646       (arg1)->SetWrapMode(arg2);
82647     } catch (std::out_of_range& e) {
82648       {
82649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82650       };
82651     } catch (std::exception& e) {
82652       {
82653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82654       };
82655     } catch (Dali::DaliException e) {
82656       {
82657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82658       };
82659     } catch (...) {
82660       {
82661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82662       };
82663     }
82664   }
82665
82666 }
82667
82668
82669 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
82670   unsigned int jresult ;
82671   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82672   bool result;
82673
82674   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82675   {
82676     try {
82677       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
82678     } catch (std::out_of_range& e) {
82679       {
82680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82681       };
82682     } catch (std::exception& e) {
82683       {
82684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82685       };
82686     } catch (Dali::DaliException e) {
82687       {
82688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82689       };
82690     } catch (...) {
82691       {
82692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82693       };
82694     }
82695   }
82696
82697   jresult = result;
82698   return jresult;
82699 }
82700
82701
82702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
82703   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82704   Dali::Actor arg2 ;
82705   Dali::Actor *argp2 ;
82706
82707   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82708   argp2 = (Dali::Actor *)jarg2;
82709   if (!argp2) {
82710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82711     return ;
82712   }
82713   arg2 = *argp2;
82714   {
82715     try {
82716       (arg1)->SetFocusIndicatorActor(arg2);
82717     } catch (std::out_of_range& e) {
82718       {
82719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82720       };
82721     } catch (std::exception& e) {
82722       {
82723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82724       };
82725     } catch (Dali::DaliException e) {
82726       {
82727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82728       };
82729     } catch (...) {
82730       {
82731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82732       };
82733     }
82734   }
82735
82736 }
82737
82738
82739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
82740   void * jresult ;
82741   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82742   Dali::Actor result;
82743
82744   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82745   {
82746     try {
82747       result = (arg1)->GetFocusIndicatorActor();
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 (Dali::DaliException e) {
82757       {
82758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82759       };
82760     } catch (...) {
82761       {
82762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82763       };
82764     }
82765   }
82766
82767   jresult = new Dali::Actor((const Dali::Actor &)result);
82768   return jresult;
82769 }
82770
82771
82772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
82773   void * jresult ;
82774   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82775   Dali::Actor arg2 ;
82776   Dali::Actor *argp2 ;
82777   Dali::Actor result;
82778
82779   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82780   argp2 = (Dali::Actor *)jarg2;
82781   if (!argp2) {
82782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82783     return 0;
82784   }
82785   arg2 = *argp2;
82786   {
82787     try {
82788       result = (arg1)->GetFocusGroup(arg2);
82789     } catch (std::out_of_range& e) {
82790       {
82791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82792       };
82793     } catch (std::exception& e) {
82794       {
82795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82796       };
82797     } catch (Dali::DaliException e) {
82798       {
82799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82800       };
82801     } catch (...) {
82802       {
82803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82804       };
82805     }
82806   }
82807
82808   jresult = new Dali::Actor((const Dali::Actor &)result);
82809   return jresult;
82810 }
82811
82812
82813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
82814   void * jresult ;
82815   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82816   Dali::Vector2 result;
82817
82818   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82819   {
82820     try {
82821       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
82822     } catch (std::out_of_range& e) {
82823       {
82824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82825       };
82826     } catch (std::exception& e) {
82827       {
82828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82829       };
82830     } catch (Dali::DaliException e) {
82831       {
82832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82833       };
82834     } catch (...) {
82835       {
82836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82837       };
82838     }
82839   }
82840
82841   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
82842   return jresult;
82843 }
82844
82845
82846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
82847   void * jresult ;
82848   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82849   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
82850
82851   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82852   {
82853     try {
82854       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
82855     } catch (std::out_of_range& e) {
82856       {
82857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82858       };
82859     } catch (std::exception& e) {
82860       {
82861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82862       };
82863     } catch (Dali::DaliException e) {
82864       {
82865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82866       };
82867     } catch (...) {
82868       {
82869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82870       };
82871     }
82872   }
82873
82874   jresult = (void *)result;
82875   return jresult;
82876 }
82877
82878
82879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
82880   void * jresult ;
82881   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82882   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
82883
82884   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82885   {
82886     try {
82887       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
82888     } catch (std::out_of_range& e) {
82889       {
82890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82891       };
82892     } catch (std::exception& e) {
82893       {
82894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82895       };
82896     } catch (Dali::DaliException e) {
82897       {
82898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82899       };
82900     } catch (...) {
82901       {
82902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82903       };
82904     }
82905   }
82906
82907   jresult = (void *)result;
82908   return jresult;
82909 }
82910
82911
82912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
82913   void * jresult ;
82914   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82915   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
82916
82917   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82918   {
82919     try {
82920       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
82921     } catch (std::out_of_range& e) {
82922       {
82923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82924       };
82925     } catch (std::exception& e) {
82926       {
82927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82928       };
82929     } catch (Dali::DaliException e) {
82930       {
82931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82932       };
82933     } catch (...) {
82934       {
82935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82936       };
82937     }
82938   }
82939
82940   jresult = (void *)result;
82941   return jresult;
82942 }
82943
82944
82945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
82946   void * jresult ;
82947   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82948   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82949
82950   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82951   {
82952     try {
82953       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
82954     } catch (std::out_of_range& e) {
82955       {
82956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82957       };
82958     } catch (std::exception& e) {
82959       {
82960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82961       };
82962     } catch (Dali::DaliException e) {
82963       {
82964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82965       };
82966     } catch (...) {
82967       {
82968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82969       };
82970     }
82971   }
82972
82973   jresult = (void *)result;
82974   return jresult;
82975 }
82976
82977
82978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
82979   void * jresult ;
82980   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
82981   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
82982
82983   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
82984   {
82985     try {
82986       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
82987     } catch (std::out_of_range& e) {
82988       {
82989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82990       };
82991     } catch (std::exception& e) {
82992       {
82993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82994       };
82995     } catch (Dali::DaliException e) {
82996       {
82997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82998       };
82999     } catch (...) {
83000       {
83001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83002       };
83003     }
83004   }
83005
83006   jresult = (void *)result;
83007   return jresult;
83008 }
83009
83010
83011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
83012   void * jresult ;
83013   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83014   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83015
83016   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83017   {
83018     try {
83019       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
83020     } catch (std::out_of_range& e) {
83021       {
83022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83023       };
83024     } catch (std::exception& e) {
83025       {
83026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83027       };
83028     } catch (Dali::DaliException e) {
83029       {
83030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83031       };
83032     } catch (...) {
83033       {
83034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83035       };
83036     }
83037   }
83038
83039   jresult = (void *)result;
83040   return jresult;
83041 }
83042
83043
83044 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
83045   void * jresult ;
83046   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83047   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83048
83049   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83050   {
83051     try {
83052       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
83053     } catch (std::out_of_range& e) {
83054       {
83055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83056       };
83057     } catch (std::exception& e) {
83058       {
83059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83060       };
83061     } catch (Dali::DaliException e) {
83062       {
83063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83064       };
83065     } catch (...) {
83066       {
83067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83068       };
83069     }
83070   }
83071
83072   jresult = (void *)result;
83073   return jresult;
83074 }
83075
83076
83077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
83078   void * jresult ;
83079   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83080   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83081
83082   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83083   {
83084     try {
83085       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
83086     } catch (std::out_of_range& e) {
83087       {
83088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83089       };
83090     } catch (std::exception& e) {
83091       {
83092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83093       };
83094     } catch (Dali::DaliException e) {
83095       {
83096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83097       };
83098     } catch (...) {
83099       {
83100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83101       };
83102     }
83103   }
83104
83105   jresult = (void *)result;
83106   return jresult;
83107 }
83108
83109
83110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
83111   void * jresult ;
83112   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83113   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83114
83115   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83116   {
83117     try {
83118       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
83119     } catch (std::out_of_range& e) {
83120       {
83121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83122       };
83123     } catch (std::exception& e) {
83124       {
83125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83126       };
83127     } catch (Dali::DaliException e) {
83128       {
83129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83130       };
83131     } catch (...) {
83132       {
83133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83134       };
83135     }
83136   }
83137
83138   jresult = (void *)result;
83139   return jresult;
83140 }
83141
83142
83143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
83144   void * jresult ;
83145   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83146   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83147
83148   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83149   {
83150     try {
83151       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
83152     } catch (std::out_of_range& e) {
83153       {
83154         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83155       };
83156     } catch (std::exception& e) {
83157       {
83158         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83159       };
83160     } catch (Dali::DaliException e) {
83161       {
83162         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83163       };
83164     } catch (...) {
83165       {
83166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83167       };
83168     }
83169   }
83170
83171   jresult = (void *)result;
83172   return jresult;
83173 }
83174
83175
83176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
83177   void * jresult ;
83178   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83179   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83180
83181   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83182   {
83183     try {
83184       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
83185     } catch (std::out_of_range& e) {
83186       {
83187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83188       };
83189     } catch (std::exception& e) {
83190       {
83191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83192       };
83193     } catch (Dali::DaliException e) {
83194       {
83195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83196       };
83197     } catch (...) {
83198       {
83199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83200       };
83201     }
83202   }
83203
83204   jresult = (void *)result;
83205   return jresult;
83206 }
83207
83208
83209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
83210   void * jresult ;
83211   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83212   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83213
83214   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83215   {
83216     try {
83217       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
83218     } catch (std::out_of_range& e) {
83219       {
83220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83221       };
83222     } catch (std::exception& e) {
83223       {
83224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83225       };
83226     } catch (Dali::DaliException e) {
83227       {
83228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83229       };
83230     } catch (...) {
83231       {
83232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83233       };
83234     }
83235   }
83236
83237   jresult = (void *)result;
83238   return jresult;
83239 }
83240
83241
83242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
83243   void * jresult ;
83244   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83245   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83246
83247   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83248   {
83249     try {
83250       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
83251     } catch (std::out_of_range& e) {
83252       {
83253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83254       };
83255     } catch (std::exception& e) {
83256       {
83257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83258       };
83259     } catch (Dali::DaliException e) {
83260       {
83261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83262       };
83263     } catch (...) {
83264       {
83265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83266       };
83267     }
83268   }
83269
83270   jresult = (void *)result;
83271   return jresult;
83272 }
83273
83274
83275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
83276   void * jresult ;
83277   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83278   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83279
83280   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83281   {
83282     try {
83283       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
83284     } catch (std::out_of_range& e) {
83285       {
83286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83287       };
83288     } catch (std::exception& e) {
83289       {
83290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83291       };
83292     } catch (Dali::DaliException e) {
83293       {
83294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83295       };
83296     } catch (...) {
83297       {
83298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83299       };
83300     }
83301   }
83302
83303   jresult = (void *)result;
83304   return jresult;
83305 }
83306
83307
83308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
83309   void * jresult ;
83310   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83311   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83312
83313   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83314   {
83315     try {
83316       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
83317     } catch (std::out_of_range& e) {
83318       {
83319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83320       };
83321     } catch (std::exception& e) {
83322       {
83323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83324       };
83325     } catch (Dali::DaliException e) {
83326       {
83327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83328       };
83329     } catch (...) {
83330       {
83331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83332       };
83333     }
83334   }
83335
83336   jresult = (void *)result;
83337   return jresult;
83338 }
83339
83340
83341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
83342   void * jresult ;
83343   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83344   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83345
83346   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83347   {
83348     try {
83349       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
83350     } catch (std::out_of_range& e) {
83351       {
83352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83353       };
83354     } catch (std::exception& e) {
83355       {
83356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83357       };
83358     } catch (Dali::DaliException e) {
83359       {
83360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83361       };
83362     } catch (...) {
83363       {
83364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83365       };
83366     }
83367   }
83368
83369   jresult = (void *)result;
83370   return jresult;
83371 }
83372
83373
83374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
83375   void * jresult ;
83376   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83377   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83378
83379   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83380   {
83381     try {
83382       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
83383     } catch (std::out_of_range& e) {
83384       {
83385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83386       };
83387     } catch (std::exception& e) {
83388       {
83389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83390       };
83391     } catch (Dali::DaliException e) {
83392       {
83393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83394       };
83395     } catch (...) {
83396       {
83397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83398       };
83399     }
83400   }
83401
83402   jresult = (void *)result;
83403   return jresult;
83404 }
83405
83406
83407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
83408   void * jresult ;
83409   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83410   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83411
83412   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83413   {
83414     try {
83415       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
83416     } catch (std::out_of_range& e) {
83417       {
83418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83419       };
83420     } catch (std::exception& e) {
83421       {
83422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83423       };
83424     } catch (Dali::DaliException e) {
83425       {
83426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83427       };
83428     } catch (...) {
83429       {
83430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83431       };
83432     }
83433   }
83434
83435   jresult = (void *)result;
83436   return jresult;
83437 }
83438
83439
83440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
83441   void * jresult ;
83442   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83443   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83444
83445   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83446   {
83447     try {
83448       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
83449     } catch (std::out_of_range& e) {
83450       {
83451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83452       };
83453     } catch (std::exception& e) {
83454       {
83455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83456       };
83457     } catch (Dali::DaliException e) {
83458       {
83459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83460       };
83461     } catch (...) {
83462       {
83463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83464       };
83465     }
83466   }
83467
83468   jresult = (void *)result;
83469   return jresult;
83470 }
83471
83472
83473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
83474   void * jresult ;
83475   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83476   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83477
83478   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83479   {
83480     try {
83481       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
83482     } catch (std::out_of_range& e) {
83483       {
83484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83485       };
83486     } catch (std::exception& e) {
83487       {
83488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83489       };
83490     } catch (Dali::DaliException e) {
83491       {
83492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83493       };
83494     } catch (...) {
83495       {
83496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83497       };
83498     }
83499   }
83500
83501   jresult = (void *)result;
83502   return jresult;
83503 }
83504
83505
83506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
83507   void * jresult ;
83508   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83509   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83510
83511   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83512   {
83513     try {
83514       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
83515     } catch (std::out_of_range& e) {
83516       {
83517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83518       };
83519     } catch (std::exception& e) {
83520       {
83521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83522       };
83523     } catch (Dali::DaliException e) {
83524       {
83525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83526       };
83527     } catch (...) {
83528       {
83529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83530       };
83531     }
83532   }
83533
83534   jresult = (void *)result;
83535   return jresult;
83536 }
83537
83538
83539 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
83540   void * jresult ;
83541   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83542   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83543
83544   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83545   {
83546     try {
83547       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
83548     } catch (std::out_of_range& e) {
83549       {
83550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83551       };
83552     } catch (std::exception& e) {
83553       {
83554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83555       };
83556     } catch (Dali::DaliException e) {
83557       {
83558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83559       };
83560     } catch (...) {
83561       {
83562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83563       };
83564     }
83565   }
83566
83567   jresult = (void *)result;
83568   return jresult;
83569 }
83570
83571
83572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
83573   void * jresult ;
83574   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83575   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83576
83577   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83578   {
83579     try {
83580       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
83581     } catch (std::out_of_range& e) {
83582       {
83583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83584       };
83585     } catch (std::exception& e) {
83586       {
83587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83588       };
83589     } catch (Dali::DaliException e) {
83590       {
83591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83592       };
83593     } catch (...) {
83594       {
83595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83596       };
83597     }
83598   }
83599
83600   jresult = (void *)result;
83601   return jresult;
83602 }
83603
83604
83605 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
83606   void * jresult ;
83607   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83608   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83609
83610   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83611   {
83612     try {
83613       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
83614     } catch (std::out_of_range& e) {
83615       {
83616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83617       };
83618     } catch (std::exception& e) {
83619       {
83620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83621       };
83622     } catch (Dali::DaliException e) {
83623       {
83624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83625       };
83626     } catch (...) {
83627       {
83628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83629       };
83630     }
83631   }
83632
83633   jresult = (void *)result;
83634   return jresult;
83635 }
83636
83637
83638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
83639   void * jresult ;
83640   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83641   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83642
83643   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83644   {
83645     try {
83646       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
83647     } catch (std::out_of_range& e) {
83648       {
83649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83650       };
83651     } catch (std::exception& e) {
83652       {
83653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83654       };
83655     } catch (Dali::DaliException e) {
83656       {
83657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83658       };
83659     } catch (...) {
83660       {
83661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83662       };
83663     }
83664   }
83665
83666   jresult = (void *)result;
83667   return jresult;
83668 }
83669
83670
83671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
83672   void * jresult ;
83673   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83674   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83675
83676   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83677   {
83678     try {
83679       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
83680     } catch (std::out_of_range& e) {
83681       {
83682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83683       };
83684     } catch (std::exception& e) {
83685       {
83686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83687       };
83688     } catch (Dali::DaliException e) {
83689       {
83690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83691       };
83692     } catch (...) {
83693       {
83694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83695       };
83696     }
83697   }
83698
83699   jresult = (void *)result;
83700   return jresult;
83701 }
83702
83703
83704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadIndicatorInformationSignal(void * jarg1) {
83705   void * jresult ;
83706   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83707   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83708
83709   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83710   {
83711     try {
83712       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadIndicatorInformationSignal();
83713     } catch (std::out_of_range& e) {
83714       {
83715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83716       };
83717     } catch (std::exception& e) {
83718       {
83719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83720       };
83721     } catch (Dali::DaliException e) {
83722       {
83723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83724       };
83725     } catch (...) {
83726       {
83727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83728       };
83729     }
83730   }
83731
83732   jresult = (void *)result;
83733   return jresult;
83734 }
83735
83736
83737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
83738   void * jresult ;
83739   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83740   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83741
83742   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83743   {
83744     try {
83745       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
83746     } catch (std::out_of_range& e) {
83747       {
83748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83749       };
83750     } catch (std::exception& e) {
83751       {
83752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83753       };
83754     } catch (Dali::DaliException e) {
83755       {
83756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83757       };
83758     } catch (...) {
83759       {
83760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83761       };
83762     }
83763   }
83764
83765   jresult = (void *)result;
83766   return jresult;
83767 }
83768
83769
83770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
83771   void * jresult ;
83772   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83773   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
83774
83775   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83776   {
83777     try {
83778       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
83779     } catch (std::out_of_range& e) {
83780       {
83781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83782       };
83783     } catch (std::exception& e) {
83784       {
83785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83786       };
83787     } catch (Dali::DaliException e) {
83788       {
83789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83790       };
83791     } catch (...) {
83792       {
83793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83794       };
83795     }
83796   }
83797
83798   jresult = (void *)result;
83799   return jresult;
83800 }
83801
83802
83803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
83804   void * jresult ;
83805   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
83806   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
83807
83808   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
83809   {
83810     try {
83811       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
83812     } catch (std::out_of_range& e) {
83813       {
83814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83815       };
83816     } catch (std::exception& e) {
83817       {
83818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83819       };
83820     } catch (Dali::DaliException e) {
83821       {
83822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83823       };
83824     } catch (...) {
83825       {
83826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83827       };
83828     }
83829   }
83830
83831   jresult = (void *)result;
83832   return jresult;
83833 }
83834
83835
83836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
83837   void * jresult ;
83838   Dali::Toolkit::StyleManager *result = 0 ;
83839
83840   {
83841     try {
83842       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
83843     } catch (std::out_of_range& e) {
83844       {
83845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83846       };
83847     } catch (std::exception& e) {
83848       {
83849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83850       };
83851     } catch (Dali::DaliException e) {
83852       {
83853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83854       };
83855     } catch (...) {
83856       {
83857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83858       };
83859     }
83860   }
83861
83862   jresult = (void *)result;
83863   return jresult;
83864 }
83865
83866
83867 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
83868   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83869
83870   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
83871   {
83872     try {
83873       delete arg1;
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 (Dali::DaliException e) {
83883       {
83884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83885       };
83886     } catch (...) {
83887       {
83888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83889       };
83890     }
83891   }
83892
83893 }
83894
83895
83896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
83897   void * jresult ;
83898   Dali::Toolkit::StyleManager result;
83899
83900   {
83901     try {
83902       result = Dali::Toolkit::StyleManager::Get();
83903     } catch (std::out_of_range& e) {
83904       {
83905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83906       };
83907     } catch (std::exception& e) {
83908       {
83909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83910       };
83911     } catch (Dali::DaliException e) {
83912       {
83913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83914       };
83915     } catch (...) {
83916       {
83917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83918       };
83919     }
83920   }
83921
83922   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
83923   return jresult;
83924 }
83925
83926
83927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
83928   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83929   std::string *arg2 = 0 ;
83930
83931   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
83932   if (!jarg2) {
83933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
83934     return ;
83935   }
83936   std::string arg2_str(jarg2);
83937   arg2 = &arg2_str;
83938   {
83939     try {
83940       (arg1)->ApplyTheme((std::string const &)*arg2);
83941     } catch (std::out_of_range& e) {
83942       {
83943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83944       };
83945     } catch (std::exception& e) {
83946       {
83947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83948       };
83949     } catch (Dali::DaliException e) {
83950       {
83951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83952       };
83953     } catch (...) {
83954       {
83955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83956       };
83957     }
83958   }
83959
83960
83961   //argout typemap for const std::string&
83962
83963 }
83964
83965
83966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
83967   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83968
83969   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
83970   {
83971     try {
83972       (arg1)->ApplyDefaultTheme();
83973     } catch (std::out_of_range& e) {
83974       {
83975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83976       };
83977     } catch (std::exception& e) {
83978       {
83979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83980       };
83981     } catch (Dali::DaliException e) {
83982       {
83983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83984       };
83985     } catch (...) {
83986       {
83987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83988       };
83989     }
83990   }
83991
83992 }
83993
83994
83995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
83996   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
83997   std::string *arg2 = 0 ;
83998   Dali::Property::Value *arg3 = 0 ;
83999
84000   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
84001   if (!jarg2) {
84002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84003     return ;
84004   }
84005   std::string arg2_str(jarg2);
84006   arg2 = &arg2_str;
84007   arg3 = (Dali::Property::Value *)jarg3;
84008   if (!arg3) {
84009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
84010     return ;
84011   }
84012   {
84013     try {
84014       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
84015     } catch (std::out_of_range& e) {
84016       {
84017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84018       };
84019     } catch (std::exception& e) {
84020       {
84021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84022       };
84023     } catch (Dali::DaliException e) {
84024       {
84025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84026       };
84027     } catch (...) {
84028       {
84029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84030       };
84031     }
84032   }
84033
84034
84035   //argout typemap for const std::string&
84036
84037 }
84038
84039
84040 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
84041   unsigned int jresult ;
84042   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
84043   std::string *arg2 = 0 ;
84044   Dali::Property::Value *arg3 = 0 ;
84045   bool result;
84046
84047   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
84048   if (!jarg2) {
84049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84050     return 0;
84051   }
84052   std::string arg2_str(jarg2);
84053   arg2 = &arg2_str;
84054   arg3 = (Dali::Property::Value *)jarg3;
84055   if (!arg3) {
84056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
84057     return 0;
84058   }
84059   {
84060     try {
84061       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
84062     } catch (std::out_of_range& e) {
84063       {
84064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84065       };
84066     } catch (std::exception& e) {
84067       {
84068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84069       };
84070     } catch (Dali::DaliException e) {
84071       {
84072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84073       };
84074     } catch (...) {
84075       {
84076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84077       };
84078     }
84079   }
84080
84081   jresult = result;
84082
84083   //argout typemap for const std::string&
84084
84085   return jresult;
84086 }
84087
84088
84089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
84090   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
84091   Dali::Toolkit::Control arg2 ;
84092   std::string *arg3 = 0 ;
84093   std::string *arg4 = 0 ;
84094   Dali::Toolkit::Control *argp2 ;
84095
84096   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
84097   argp2 = (Dali::Toolkit::Control *)jarg2;
84098   if (!argp2) {
84099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
84100     return ;
84101   }
84102   arg2 = *argp2;
84103   if (!jarg3) {
84104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84105     return ;
84106   }
84107   std::string arg3_str(jarg3);
84108   arg3 = &arg3_str;
84109   if (!jarg4) {
84110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84111     return ;
84112   }
84113   std::string arg4_str(jarg4);
84114   arg4 = &arg4_str;
84115   {
84116     try {
84117       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
84118     } catch (std::out_of_range& e) {
84119       {
84120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84121       };
84122     } catch (std::exception& e) {
84123       {
84124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84125       };
84126     } catch (Dali::DaliException e) {
84127       {
84128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84129       };
84130     } catch (...) {
84131       {
84132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84133       };
84134     }
84135   }
84136
84137
84138   //argout typemap for const std::string&
84139
84140
84141   //argout typemap for const std::string&
84142
84143 }
84144
84145
84146 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
84147   void * jresult ;
84148   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
84149   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
84150
84151   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
84152   {
84153     try {
84154       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
84155     } catch (std::out_of_range& e) {
84156       {
84157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84158       };
84159     } catch (std::exception& e) {
84160       {
84161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84162       };
84163     } catch (Dali::DaliException e) {
84164       {
84165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84166       };
84167     } catch (...) {
84168       {
84169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84170       };
84171     }
84172   }
84173
84174   jresult = (void *)result;
84175   return jresult;
84176 }
84177
84178
84179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
84180   int jresult ;
84181   int result;
84182
84183   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
84184   jresult = (int)result;
84185   return jresult;
84186 }
84187
84188
84189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
84190   int jresult ;
84191   int result;
84192
84193   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
84194   jresult = (int)result;
84195   return jresult;
84196 }
84197
84198
84199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
84200   int jresult ;
84201   int result;
84202
84203   result = (int)Dali::Toolkit::Slider::Property::VALUE;
84204   jresult = (int)result;
84205   return jresult;
84206 }
84207
84208
84209 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
84210   int jresult ;
84211   int result;
84212
84213   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
84214   jresult = (int)result;
84215   return jresult;
84216 }
84217
84218
84219 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
84220   int jresult ;
84221   int result;
84222
84223   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
84224   jresult = (int)result;
84225   return jresult;
84226 }
84227
84228
84229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
84230   int jresult ;
84231   int result;
84232
84233   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
84234   jresult = (int)result;
84235   return jresult;
84236 }
84237
84238
84239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
84240   int jresult ;
84241   int result;
84242
84243   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
84244   jresult = (int)result;
84245   return jresult;
84246 }
84247
84248
84249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
84250   int jresult ;
84251   int result;
84252
84253   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
84254   jresult = (int)result;
84255   return jresult;
84256 }
84257
84258
84259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
84260   int jresult ;
84261   int result;
84262
84263   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
84264   jresult = (int)result;
84265   return jresult;
84266 }
84267
84268
84269 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
84270   int jresult ;
84271   int result;
84272
84273   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
84274   jresult = (int)result;
84275   return jresult;
84276 }
84277
84278
84279 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
84280   int jresult ;
84281   int result;
84282
84283   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
84284   jresult = (int)result;
84285   return jresult;
84286 }
84287
84288
84289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
84290   int jresult ;
84291   int result;
84292
84293   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
84294   jresult = (int)result;
84295   return jresult;
84296 }
84297
84298
84299 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
84300   int jresult ;
84301   int result;
84302
84303   result = (int)Dali::Toolkit::Slider::Property::MARKS;
84304   jresult = (int)result;
84305   return jresult;
84306 }
84307
84308
84309 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
84310   int jresult ;
84311   int result;
84312
84313   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
84314   jresult = (int)result;
84315   return jresult;
84316 }
84317
84318
84319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
84320   int jresult ;
84321   int result;
84322
84323   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
84324   jresult = (int)result;
84325   return jresult;
84326 }
84327
84328
84329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
84330   void * jresult ;
84331   Dali::Toolkit::Slider::Property *result = 0 ;
84332
84333   {
84334     try {
84335       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
84336     } catch (std::out_of_range& e) {
84337       {
84338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84339       };
84340     } catch (std::exception& e) {
84341       {
84342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84343       };
84344     } catch (Dali::DaliException e) {
84345       {
84346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84347       };
84348     } catch (...) {
84349       {
84350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84351       };
84352     }
84353   }
84354
84355   jresult = (void *)result;
84356   return jresult;
84357 }
84358
84359
84360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
84361   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
84362
84363   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
84364   {
84365     try {
84366       delete arg1;
84367     } catch (std::out_of_range& e) {
84368       {
84369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84370       };
84371     } catch (std::exception& e) {
84372       {
84373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84374       };
84375     } catch (Dali::DaliException e) {
84376       {
84377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84378       };
84379     } catch (...) {
84380       {
84381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84382       };
84383     }
84384   }
84385
84386 }
84387
84388
84389 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
84390   void * jresult ;
84391   Dali::Toolkit::Slider result;
84392
84393   {
84394     try {
84395       result = Dali::Toolkit::Slider::New();
84396     } catch (std::out_of_range& e) {
84397       {
84398         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84399       };
84400     } catch (std::exception& e) {
84401       {
84402         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84403       };
84404     } catch (Dali::DaliException e) {
84405       {
84406         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84407       };
84408     } catch (...) {
84409       {
84410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84411       };
84412     }
84413   }
84414
84415   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
84416   return jresult;
84417 }
84418
84419
84420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
84421   void * jresult ;
84422   Dali::Toolkit::Slider *result = 0 ;
84423
84424   {
84425     try {
84426       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
84427     } catch (std::out_of_range& e) {
84428       {
84429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84430       };
84431     } catch (std::exception& e) {
84432       {
84433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84434       };
84435     } catch (Dali::DaliException e) {
84436       {
84437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84438       };
84439     } catch (...) {
84440       {
84441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84442       };
84443     }
84444   }
84445
84446   jresult = (void *)result;
84447   return jresult;
84448 }
84449
84450
84451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
84452   void * jresult ;
84453   Dali::Toolkit::Slider *arg1 = 0 ;
84454   Dali::Toolkit::Slider *result = 0 ;
84455
84456   arg1 = (Dali::Toolkit::Slider *)jarg1;
84457   if (!arg1) {
84458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
84459     return 0;
84460   }
84461   {
84462     try {
84463       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
84464     } catch (std::out_of_range& e) {
84465       {
84466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84467       };
84468     } catch (std::exception& e) {
84469       {
84470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84471       };
84472     } catch (Dali::DaliException e) {
84473       {
84474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84475       };
84476     } catch (...) {
84477       {
84478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84479       };
84480     }
84481   }
84482
84483   jresult = (void *)result;
84484   return jresult;
84485 }
84486
84487
84488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
84489   void * jresult ;
84490   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
84491   Dali::Toolkit::Slider *arg2 = 0 ;
84492   Dali::Toolkit::Slider *result = 0 ;
84493
84494   arg1 = (Dali::Toolkit::Slider *)jarg1;
84495   arg2 = (Dali::Toolkit::Slider *)jarg2;
84496   if (!arg2) {
84497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
84498     return 0;
84499   }
84500   {
84501     try {
84502       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
84503     } catch (std::out_of_range& e) {
84504       {
84505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84506       };
84507     } catch (std::exception& e) {
84508       {
84509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84510       };
84511     } catch (Dali::DaliException e) {
84512       {
84513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84514       };
84515     } catch (...) {
84516       {
84517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84518       };
84519     }
84520   }
84521
84522   jresult = (void *)result;
84523   return jresult;
84524 }
84525
84526
84527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
84528   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
84529
84530   arg1 = (Dali::Toolkit::Slider *)jarg1;
84531   {
84532     try {
84533       delete arg1;
84534     } catch (std::out_of_range& e) {
84535       {
84536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84537       };
84538     } catch (std::exception& e) {
84539       {
84540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84541       };
84542     } catch (Dali::DaliException e) {
84543       {
84544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84545       };
84546     } catch (...) {
84547       {
84548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84549       };
84550     }
84551   }
84552
84553 }
84554
84555
84556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
84557   void * jresult ;
84558   Dali::BaseHandle arg1 ;
84559   Dali::BaseHandle *argp1 ;
84560   Dali::Toolkit::Slider result;
84561
84562   argp1 = (Dali::BaseHandle *)jarg1;
84563   if (!argp1) {
84564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84565     return 0;
84566   }
84567   arg1 = *argp1;
84568   {
84569     try {
84570       result = Dali::Toolkit::Slider::DownCast(arg1);
84571     } catch (std::out_of_range& e) {
84572       {
84573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84574       };
84575     } catch (std::exception& e) {
84576       {
84577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84578       };
84579     } catch (Dali::DaliException e) {
84580       {
84581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84582       };
84583     } catch (...) {
84584       {
84585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84586       };
84587     }
84588   }
84589
84590   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
84591   return jresult;
84592 }
84593
84594
84595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
84596   void * jresult ;
84597   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
84598   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
84599
84600   arg1 = (Dali::Toolkit::Slider *)jarg1;
84601   {
84602     try {
84603       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
84604     } catch (std::out_of_range& e) {
84605       {
84606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84607       };
84608     } catch (std::exception& e) {
84609       {
84610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84611       };
84612     } catch (Dali::DaliException e) {
84613       {
84614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84615       };
84616     } catch (...) {
84617       {
84618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84619       };
84620     }
84621   }
84622
84623   jresult = (void *)result;
84624   return jresult;
84625 }
84626
84627
84628 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
84629   void * jresult ;
84630   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
84631   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
84632
84633   arg1 = (Dali::Toolkit::Slider *)jarg1;
84634   {
84635     try {
84636       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
84637     } catch (std::out_of_range& e) {
84638       {
84639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84640       };
84641     } catch (std::exception& e) {
84642       {
84643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84644       };
84645     } catch (Dali::DaliException e) {
84646       {
84647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84648       };
84649     } catch (...) {
84650       {
84651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84652       };
84653     }
84654   }
84655
84656   jresult = (void *)result;
84657   return jresult;
84658 }
84659
84660
84661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
84662   void * jresult ;
84663   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
84664   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
84665
84666   arg1 = (Dali::Toolkit::Slider *)jarg1;
84667   {
84668     try {
84669       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
84670     } catch (std::out_of_range& e) {
84671       {
84672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84673       };
84674     } catch (std::exception& e) {
84675       {
84676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84677       };
84678     } catch (Dali::DaliException e) {
84679       {
84680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84681       };
84682     } catch (...) {
84683       {
84684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84685       };
84686     }
84687   }
84688
84689   jresult = (void *)result;
84690   return jresult;
84691 }
84692
84693
84694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
84695   int jresult ;
84696   int result;
84697
84698   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
84699   jresult = (int)result;
84700   return jresult;
84701 }
84702
84703
84704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
84705   int jresult ;
84706   int result;
84707
84708   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
84709   jresult = (int)result;
84710   return jresult;
84711 }
84712
84713
84714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
84715   int jresult ;
84716   int result;
84717
84718   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
84719   jresult = (int)result;
84720   return jresult;
84721 }
84722
84723
84724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
84725   int jresult ;
84726   int result;
84727
84728   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
84729   jresult = (int)result;
84730   return jresult;
84731 }
84732
84733
84734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
84735   int result;
84736
84737   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
84738
84739   return result;
84740 }
84741
84742
84743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
84744   void * jresult ;
84745   Dali::Toolkit::VideoView::Property *result = 0 ;
84746
84747   {
84748     try {
84749       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
84750     } catch (std::out_of_range& e) {
84751       {
84752         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84753       };
84754     } catch (std::exception& e) {
84755       {
84756         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84757       };
84758     } catch (Dali::DaliException e) {
84759       {
84760         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84761       };
84762     } catch (...) {
84763       {
84764         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84765       };
84766     }
84767   }
84768
84769   jresult = (void *)result;
84770   return jresult;
84771 }
84772
84773
84774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
84775   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
84776
84777   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
84778   {
84779     try {
84780       delete arg1;
84781     } catch (std::out_of_range& e) {
84782       {
84783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84784       };
84785     } catch (std::exception& e) {
84786       {
84787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84788       };
84789     } catch (Dali::DaliException e) {
84790       {
84791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84792       };
84793     } catch (...) {
84794       {
84795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84796       };
84797     }
84798   }
84799
84800 }
84801
84802
84803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
84804   void * jresult ;
84805   Dali::Toolkit::VideoView result;
84806
84807   {
84808     try {
84809       result = Dali::Toolkit::VideoView::New();
84810     } catch (std::out_of_range& e) {
84811       {
84812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84813       };
84814     } catch (std::exception& e) {
84815       {
84816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84817       };
84818     } catch (Dali::DaliException e) {
84819       {
84820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84821       };
84822     } catch (...) {
84823       {
84824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84825       };
84826     }
84827   }
84828
84829   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
84830   return jresult;
84831 }
84832
84833
84834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
84835   void * jresult ;
84836   std::string *arg1 = 0 ;
84837   Dali::Toolkit::VideoView result;
84838
84839   if (!jarg1) {
84840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84841     return 0;
84842   }
84843   std::string arg1_str(jarg1);
84844   arg1 = &arg1_str;
84845   {
84846     try {
84847       result = Dali::Toolkit::VideoView::New((std::string 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 (Dali::DaliException e) {
84857       {
84858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84859       };
84860     } catch (...) {
84861       {
84862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84863       };
84864     }
84865   }
84866
84867   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
84868
84869   //argout typemap for const std::string&
84870
84871   return jresult;
84872 }
84873
84874
84875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
84876   void * jresult ;
84877   Dali::Toolkit::VideoView result;
84878   {
84879     try {
84880       result = Dali::Toolkit::VideoView::New(swCodec);
84881     } catch (std::out_of_range& e) {
84882       {
84883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84884       };
84885     } catch (std::exception& e) {
84886       {
84887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84888       };
84889     } catch (Dali::DaliException e) {
84890       {
84891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84892       };
84893     } catch (...) {
84894       {
84895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84896       };
84897     }
84898   }
84899
84900   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
84901
84902   //argout typemap for const std::string&
84903
84904   return jresult;
84905 }
84906
84907
84908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
84909   void * jresult ;
84910   std::string *arg1 = 0 ;
84911   Dali::Toolkit::VideoView result;
84912
84913   if (!jarg1) {
84914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
84915     return 0;
84916   }
84917   std::string arg1_str(jarg1);
84918   arg1 = &arg1_str;
84919   {
84920     try {
84921       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
84922     } catch (std::out_of_range& e) {
84923       {
84924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84925       };
84926     } catch (std::exception& e) {
84927       {
84928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84929       };
84930     } catch (Dali::DaliException e) {
84931       {
84932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84933       };
84934     } catch (...) {
84935       {
84936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84937       };
84938     }
84939   }
84940
84941   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
84942
84943   //argout typemap for const std::string&
84944
84945   return jresult;
84946 }
84947
84948
84949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
84950   void * jresult ;
84951   Dali::Toolkit::VideoView *result = 0 ;
84952
84953   {
84954     try {
84955       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
84956     } catch (std::out_of_range& e) {
84957       {
84958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84959       };
84960     } catch (std::exception& e) {
84961       {
84962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84963       };
84964     } catch (Dali::DaliException e) {
84965       {
84966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84967       };
84968     } catch (...) {
84969       {
84970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84971       };
84972     }
84973   }
84974
84975   jresult = (void *)result;
84976   return jresult;
84977 }
84978
84979
84980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
84981   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
84982
84983   arg1 = (Dali::Toolkit::VideoView *)jarg1;
84984   {
84985     try {
84986       delete arg1;
84987     } catch (std::out_of_range& e) {
84988       {
84989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84990       };
84991     } catch (std::exception& e) {
84992       {
84993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84994       };
84995     } catch (Dali::DaliException e) {
84996       {
84997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84998       };
84999     } catch (...) {
85000       {
85001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85002       };
85003     }
85004   }
85005
85006 }
85007
85008
85009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
85010   void * jresult ;
85011   Dali::Toolkit::VideoView *arg1 = 0 ;
85012   Dali::Toolkit::VideoView *result = 0 ;
85013
85014   arg1 = (Dali::Toolkit::VideoView *)jarg1;
85015   if (!arg1) {
85016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
85017     return 0;
85018   }
85019   {
85020     try {
85021       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
85022     } catch (std::out_of_range& e) {
85023       {
85024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85025       };
85026     } catch (std::exception& e) {
85027       {
85028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85029       };
85030     } catch (Dali::DaliException e) {
85031       {
85032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85033       };
85034     } catch (...) {
85035       {
85036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85037       };
85038     }
85039   }
85040
85041   jresult = (void *)result;
85042   return jresult;
85043 }
85044
85045
85046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
85047   void * jresult ;
85048   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
85049   Dali::Toolkit::VideoView *arg2 = 0 ;
85050   Dali::Toolkit::VideoView *result = 0 ;
85051
85052   arg1 = (Dali::Toolkit::VideoView *)jarg1;
85053   arg2 = (Dali::Toolkit::VideoView *)jarg2;
85054   if (!arg2) {
85055     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
85056     return 0;
85057   }
85058   {
85059     try {
85060       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
85061     } catch (std::out_of_range& e) {
85062       {
85063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85064       };
85065     } catch (std::exception& e) {
85066       {
85067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85068       };
85069     } catch (Dali::DaliException e) {
85070       {
85071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85072       };
85073     } catch (...) {
85074       {
85075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85076       };
85077     }
85078   }
85079
85080   jresult = (void *)result;
85081   return jresult;
85082 }
85083
85084
85085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
85086   void * jresult ;
85087   Dali::BaseHandle arg1 ;
85088   Dali::BaseHandle *argp1 ;
85089   Dali::Toolkit::VideoView result;
85090
85091   argp1 = (Dali::BaseHandle *)jarg1;
85092   if (!argp1) {
85093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85094     return 0;
85095   }
85096   arg1 = *argp1;
85097   {
85098     try {
85099       result = Dali::Toolkit::VideoView::DownCast(arg1);
85100     } catch (std::out_of_range& e) {
85101       {
85102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85103       };
85104     } catch (std::exception& e) {
85105       {
85106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85107       };
85108     } catch (Dali::DaliException e) {
85109       {
85110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85111       };
85112     } catch (...) {
85113       {
85114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85115       };
85116     }
85117   }
85118
85119   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
85120   return jresult;
85121 }
85122
85123
85124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
85125   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
85126
85127   arg1 = (Dali::Toolkit::VideoView *)jarg1;
85128   {
85129     try {
85130       (arg1)->Play();
85131     } catch (std::out_of_range& e) {
85132       {
85133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85134       };
85135     } catch (std::exception& e) {
85136       {
85137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85138       };
85139     } catch (Dali::DaliException e) {
85140       {
85141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85142       };
85143     } catch (...) {
85144       {
85145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85146       };
85147     }
85148   }
85149
85150 }
85151
85152
85153 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
85154   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
85155
85156   arg1 = (Dali::Toolkit::VideoView *)jarg1;
85157   {
85158     try {
85159       (arg1)->Pause();
85160     } catch (std::out_of_range& e) {
85161       {
85162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85163       };
85164     } catch (std::exception& e) {
85165       {
85166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85167       };
85168     } catch (Dali::DaliException e) {
85169       {
85170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85171       };
85172     } catch (...) {
85173       {
85174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85175       };
85176     }
85177   }
85178
85179 }
85180
85181
85182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
85183   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
85184
85185   arg1 = (Dali::Toolkit::VideoView *)jarg1;
85186   {
85187     try {
85188       (arg1)->Stop();
85189     } catch (std::out_of_range& e) {
85190       {
85191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85192       };
85193     } catch (std::exception& e) {
85194       {
85195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85196       };
85197     } catch (Dali::DaliException e) {
85198       {
85199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85200       };
85201     } catch (...) {
85202       {
85203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85204       };
85205     }
85206   }
85207
85208 }
85209
85210
85211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
85212   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
85213   int arg2 ;
85214
85215   arg1 = (Dali::Toolkit::VideoView *)jarg1;
85216   arg2 = (int)jarg2;
85217   {
85218     try {
85219       (arg1)->Forward(arg2);
85220     } catch (std::out_of_range& e) {
85221       {
85222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85223       };
85224     } catch (std::exception& e) {
85225       {
85226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85227       };
85228     } catch (Dali::DaliException e) {
85229       {
85230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85231       };
85232     } catch (...) {
85233       {
85234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85235       };
85236     }
85237   }
85238
85239 }
85240
85241
85242 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
85243   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
85244   int arg2 ;
85245
85246   arg1 = (Dali::Toolkit::VideoView *)jarg1;
85247   arg2 = (int)jarg2;
85248   {
85249     try {
85250       (arg1)->Backward(arg2);
85251     } catch (std::out_of_range& e) {
85252       {
85253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85254       };
85255     } catch (std::exception& e) {
85256       {
85257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85258       };
85259     } catch (Dali::DaliException e) {
85260       {
85261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85262       };
85263     } catch (...) {
85264       {
85265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85266       };
85267     }
85268   }
85269
85270 }
85271
85272
85273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
85274   void * jresult ;
85275   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
85276   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
85277
85278   arg1 = (Dali::Toolkit::VideoView *)jarg1;
85279   {
85280     try {
85281       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
85282     } catch (std::out_of_range& e) {
85283       {
85284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85285       };
85286     } catch (std::exception& e) {
85287       {
85288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85289       };
85290     } catch (Dali::DaliException e) {
85291       {
85292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85293       };
85294     } catch (...) {
85295       {
85296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85297       };
85298     }
85299   }
85300
85301   jresult = (void *)result;
85302   return jresult;
85303 }
85304
85305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
85306 {
85307   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
85308   if( arg1 == nullptr )
85309   {
85310     DALI_LOG_ERROR("VideoView is nullptr!");
85311     return nullptr;
85312   }
85313   void * ret = nullptr;
85314   {
85315     try{
85316
85317       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
85318       ret = Dali::AnyCast< void * >( result );
85319
85320     } catch (std::out_of_range& e) {
85321       {
85322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85323       };
85324     } catch (std::exception& e) {
85325       {
85326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85327       };
85328     } catch (Dali::DaliException e) {
85329       {
85330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85331       };
85332     } catch (...) {
85333       {
85334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85335       };
85336     }
85337   }
85338   return ret;
85339 }
85340
85341
85342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
85343   int jresult ;
85344   int result;
85345
85346   result = (int)Dali::Toolkit::Popup::Property::TITLE;
85347   jresult = (int)result;
85348   return jresult;
85349 }
85350
85351
85352 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
85353   int jresult ;
85354   int result;
85355
85356   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
85357   jresult = (int)result;
85358   return jresult;
85359 }
85360
85361
85362 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
85363   int jresult ;
85364   int result;
85365
85366   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
85367   jresult = (int)result;
85368   return jresult;
85369 }
85370
85371
85372 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
85373   int jresult ;
85374   int result;
85375
85376   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
85377   jresult = (int)result;
85378   return jresult;
85379 }
85380
85381
85382 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
85383   int jresult ;
85384   int result;
85385
85386   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
85387   jresult = (int)result;
85388   return jresult;
85389 }
85390
85391
85392 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
85393   int jresult ;
85394   int result;
85395
85396   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
85397   jresult = (int)result;
85398   return jresult;
85399 }
85400
85401
85402 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
85403   int jresult ;
85404   int result;
85405
85406   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
85407   jresult = (int)result;
85408   return jresult;
85409 }
85410
85411
85412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
85413   int jresult ;
85414   int result;
85415
85416   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
85417   jresult = (int)result;
85418   return jresult;
85419 }
85420
85421
85422 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
85423   int jresult ;
85424   int result;
85425
85426   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
85427   jresult = (int)result;
85428   return jresult;
85429 }
85430
85431
85432 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
85433   int jresult ;
85434   int result;
85435
85436   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
85437   jresult = (int)result;
85438   return jresult;
85439 }
85440
85441
85442 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
85443   int jresult ;
85444   int result;
85445
85446   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
85447   jresult = (int)result;
85448   return jresult;
85449 }
85450
85451
85452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
85453   int jresult ;
85454   int result;
85455
85456   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
85457   jresult = (int)result;
85458   return jresult;
85459 }
85460
85461
85462 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
85463   int jresult ;
85464   int result;
85465
85466   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
85467   jresult = (int)result;
85468   return jresult;
85469 }
85470
85471
85472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
85473   int jresult ;
85474   int result;
85475
85476   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
85477   jresult = (int)result;
85478   return jresult;
85479 }
85480
85481
85482 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
85483   int jresult ;
85484   int result;
85485
85486   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
85487   jresult = (int)result;
85488   return jresult;
85489 }
85490
85491
85492 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
85493   int jresult ;
85494   int result;
85495
85496   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
85497   jresult = (int)result;
85498   return jresult;
85499 }
85500
85501
85502 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
85503   int jresult ;
85504   int result;
85505
85506   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
85507   jresult = (int)result;
85508   return jresult;
85509 }
85510
85511
85512 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
85513   int jresult ;
85514   int result;
85515
85516   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
85517   jresult = (int)result;
85518   return jresult;
85519 }
85520
85521
85522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
85523   int jresult ;
85524   int result;
85525
85526   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
85527   jresult = (int)result;
85528   return jresult;
85529 }
85530
85531
85532 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
85533   int jresult ;
85534   int result;
85535
85536   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
85537   jresult = (int)result;
85538   return jresult;
85539 }
85540
85541
85542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
85543   int jresult ;
85544   int result;
85545
85546   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
85547   jresult = (int)result;
85548   return jresult;
85549 }
85550
85551
85552 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
85553   void * jresult ;
85554   Dali::Toolkit::Popup::Property *result = 0 ;
85555
85556   {
85557     try {
85558       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
85559     } catch (std::out_of_range& e) {
85560       {
85561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85562       };
85563     } catch (std::exception& e) {
85564       {
85565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85566       };
85567     } catch (Dali::DaliException e) {
85568       {
85569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85570       };
85571     } catch (...) {
85572       {
85573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85574       };
85575     }
85576   }
85577
85578   jresult = (void *)result;
85579   return jresult;
85580 }
85581
85582
85583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
85584   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
85585
85586   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
85587   {
85588     try {
85589       delete arg1;
85590     } catch (std::out_of_range& e) {
85591       {
85592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85593       };
85594     } catch (std::exception& e) {
85595       {
85596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85597       };
85598     } catch (Dali::DaliException e) {
85599       {
85600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85601       };
85602     } catch (...) {
85603       {
85604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85605       };
85606     }
85607   }
85608
85609 }
85610
85611
85612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
85613   void * jresult ;
85614   Dali::Toolkit::Popup *result = 0 ;
85615
85616   {
85617     try {
85618       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
85619     } catch (std::out_of_range& e) {
85620       {
85621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85622       };
85623     } catch (std::exception& e) {
85624       {
85625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85626       };
85627     } catch (Dali::DaliException e) {
85628       {
85629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85630       };
85631     } catch (...) {
85632       {
85633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85634       };
85635     }
85636   }
85637
85638   jresult = (void *)result;
85639   return jresult;
85640 }
85641
85642
85643 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
85644   void * jresult ;
85645   Dali::Toolkit::Popup result;
85646
85647   {
85648     try {
85649       result = Dali::Toolkit::Popup::New();
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 (Dali::DaliException e) {
85659       {
85660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85661       };
85662     } catch (...) {
85663       {
85664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85665       };
85666     }
85667   }
85668
85669   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
85670   return jresult;
85671 }
85672
85673
85674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
85675   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85676
85677   arg1 = (Dali::Toolkit::Popup *)jarg1;
85678   {
85679     try {
85680       delete arg1;
85681     } catch (std::out_of_range& e) {
85682       {
85683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85684       };
85685     } catch (std::exception& e) {
85686       {
85687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85688       };
85689     } catch (Dali::DaliException e) {
85690       {
85691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85692       };
85693     } catch (...) {
85694       {
85695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85696       };
85697     }
85698   }
85699
85700 }
85701
85702
85703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
85704   void * jresult ;
85705   Dali::Toolkit::Popup *arg1 = 0 ;
85706   Dali::Toolkit::Popup *result = 0 ;
85707
85708   arg1 = (Dali::Toolkit::Popup *)jarg1;
85709   if (!arg1) {
85710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
85711     return 0;
85712   }
85713   {
85714     try {
85715       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
85716     } catch (std::out_of_range& e) {
85717       {
85718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85719       };
85720     } catch (std::exception& e) {
85721       {
85722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85723       };
85724     } catch (Dali::DaliException e) {
85725       {
85726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85727       };
85728     } catch (...) {
85729       {
85730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85731       };
85732     }
85733   }
85734
85735   jresult = (void *)result;
85736   return jresult;
85737 }
85738
85739
85740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
85741   void * jresult ;
85742   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85743   Dali::Toolkit::Popup *arg2 = 0 ;
85744   Dali::Toolkit::Popup *result = 0 ;
85745
85746   arg1 = (Dali::Toolkit::Popup *)jarg1;
85747   arg2 = (Dali::Toolkit::Popup *)jarg2;
85748   if (!arg2) {
85749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
85750     return 0;
85751   }
85752   {
85753     try {
85754       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
85755     } catch (std::out_of_range& e) {
85756       {
85757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85758       };
85759     } catch (std::exception& e) {
85760       {
85761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85762       };
85763     } catch (Dali::DaliException e) {
85764       {
85765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85766       };
85767     } catch (...) {
85768       {
85769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85770       };
85771     }
85772   }
85773
85774   jresult = (void *)result;
85775   return jresult;
85776 }
85777
85778
85779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
85780   void * jresult ;
85781   Dali::BaseHandle arg1 ;
85782   Dali::BaseHandle *argp1 ;
85783   Dali::Toolkit::Popup result;
85784
85785   argp1 = (Dali::BaseHandle *)jarg1;
85786   if (!argp1) {
85787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85788     return 0;
85789   }
85790   arg1 = *argp1;
85791   {
85792     try {
85793       result = Dali::Toolkit::Popup::DownCast(arg1);
85794     } catch (std::out_of_range& e) {
85795       {
85796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85797       };
85798     } catch (std::exception& e) {
85799       {
85800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85801       };
85802     } catch (Dali::DaliException e) {
85803       {
85804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85805       };
85806     } catch (...) {
85807       {
85808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85809       };
85810     }
85811   }
85812
85813   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
85814   return jresult;
85815 }
85816
85817
85818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
85819   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85820   Dali::Actor arg2 ;
85821   Dali::Actor *argp2 ;
85822
85823   arg1 = (Dali::Toolkit::Popup *)jarg1;
85824   argp2 = (Dali::Actor *)jarg2;
85825   if (!argp2) {
85826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85827     return ;
85828   }
85829   arg2 = *argp2;
85830   {
85831     try {
85832       (arg1)->SetTitle(arg2);
85833     } catch (std::out_of_range& e) {
85834       {
85835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85836       };
85837     } catch (std::exception& e) {
85838       {
85839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85840       };
85841     } catch (Dali::DaliException e) {
85842       {
85843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85844       };
85845     } catch (...) {
85846       {
85847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85848       };
85849     }
85850   }
85851
85852 }
85853
85854
85855 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
85856   void * jresult ;
85857   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85858   Dali::Actor result;
85859
85860   arg1 = (Dali::Toolkit::Popup *)jarg1;
85861   {
85862     try {
85863       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
85864     } catch (std::out_of_range& e) {
85865       {
85866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85867       };
85868     } catch (std::exception& e) {
85869       {
85870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85871       };
85872     } catch (Dali::DaliException e) {
85873       {
85874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85875       };
85876     } catch (...) {
85877       {
85878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85879       };
85880     }
85881   }
85882
85883   jresult = new Dali::Actor((const Dali::Actor &)result);
85884   return jresult;
85885 }
85886
85887
85888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
85889   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85890   Dali::Actor arg2 ;
85891   Dali::Actor *argp2 ;
85892
85893   arg1 = (Dali::Toolkit::Popup *)jarg1;
85894   argp2 = (Dali::Actor *)jarg2;
85895   if (!argp2) {
85896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85897     return ;
85898   }
85899   arg2 = *argp2;
85900   {
85901     try {
85902       (arg1)->SetContent(arg2);
85903     } catch (std::out_of_range& e) {
85904       {
85905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85906       };
85907     } catch (std::exception& e) {
85908       {
85909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85910       };
85911     } catch (Dali::DaliException e) {
85912       {
85913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85914       };
85915     } catch (...) {
85916       {
85917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85918       };
85919     }
85920   }
85921
85922 }
85923
85924
85925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
85926   void * jresult ;
85927   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85928   Dali::Actor result;
85929
85930   arg1 = (Dali::Toolkit::Popup *)jarg1;
85931   {
85932     try {
85933       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
85934     } catch (std::out_of_range& e) {
85935       {
85936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85937       };
85938     } catch (std::exception& e) {
85939       {
85940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85941       };
85942     } catch (Dali::DaliException e) {
85943       {
85944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85945       };
85946     } catch (...) {
85947       {
85948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85949       };
85950     }
85951   }
85952
85953   jresult = new Dali::Actor((const Dali::Actor &)result);
85954   return jresult;
85955 }
85956
85957
85958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
85959   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85960   Dali::Actor arg2 ;
85961   Dali::Actor *argp2 ;
85962
85963   arg1 = (Dali::Toolkit::Popup *)jarg1;
85964   argp2 = (Dali::Actor *)jarg2;
85965   if (!argp2) {
85966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
85967     return ;
85968   }
85969   arg2 = *argp2;
85970   {
85971     try {
85972       (arg1)->SetFooter(arg2);
85973     } catch (std::out_of_range& e) {
85974       {
85975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85976       };
85977     } catch (std::exception& e) {
85978       {
85979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85980       };
85981     } catch (Dali::DaliException e) {
85982       {
85983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85984       };
85985     } catch (...) {
85986       {
85987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85988       };
85989     }
85990   }
85991
85992 }
85993
85994
85995 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
85996   void * jresult ;
85997   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
85998   Dali::Actor result;
85999
86000   arg1 = (Dali::Toolkit::Popup *)jarg1;
86001   {
86002     try {
86003       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
86004     } catch (std::out_of_range& e) {
86005       {
86006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86007       };
86008     } catch (std::exception& e) {
86009       {
86010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86011       };
86012     } catch (Dali::DaliException e) {
86013       {
86014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86015       };
86016     } catch (...) {
86017       {
86018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86019       };
86020     }
86021   }
86022
86023   jresult = new Dali::Actor((const Dali::Actor &)result);
86024   return jresult;
86025 }
86026
86027
86028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
86029   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86030   Dali::Toolkit::Popup::DisplayState arg2 ;
86031
86032   arg1 = (Dali::Toolkit::Popup *)jarg1;
86033   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
86034   {
86035     try {
86036       (arg1)->SetDisplayState(arg2);
86037     } catch (std::out_of_range& e) {
86038       {
86039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86040       };
86041     } catch (std::exception& e) {
86042       {
86043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86044       };
86045     } catch (Dali::DaliException e) {
86046       {
86047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86048       };
86049     } catch (...) {
86050       {
86051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86052       };
86053     }
86054   }
86055
86056 }
86057
86058
86059 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
86060   int jresult ;
86061   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86062   Dali::Toolkit::Popup::DisplayState result;
86063
86064   arg1 = (Dali::Toolkit::Popup *)jarg1;
86065   {
86066     try {
86067       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
86068     } catch (std::out_of_range& e) {
86069       {
86070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86071       };
86072     } catch (std::exception& e) {
86073       {
86074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86075       };
86076     } catch (Dali::DaliException e) {
86077       {
86078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86079       };
86080     } catch (...) {
86081       {
86082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86083       };
86084     }
86085   }
86086
86087   jresult = (int)result;
86088   return jresult;
86089 }
86090
86091
86092 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
86093   void * jresult ;
86094   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86095   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
86096
86097   arg1 = (Dali::Toolkit::Popup *)jarg1;
86098   {
86099     try {
86100       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
86101     } catch (std::out_of_range& e) {
86102       {
86103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86104       };
86105     } catch (std::exception& e) {
86106       {
86107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86108       };
86109     } catch (Dali::DaliException e) {
86110       {
86111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86112       };
86113     } catch (...) {
86114       {
86115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86116       };
86117     }
86118   }
86119
86120   jresult = (void *)result;
86121   return jresult;
86122 }
86123
86124
86125 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
86126   void * jresult ;
86127   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86128   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
86129
86130   arg1 = (Dali::Toolkit::Popup *)jarg1;
86131   {
86132     try {
86133       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
86134     } catch (std::out_of_range& e) {
86135       {
86136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86137       };
86138     } catch (std::exception& e) {
86139       {
86140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86141       };
86142     } catch (Dali::DaliException e) {
86143       {
86144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86145       };
86146     } catch (...) {
86147       {
86148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86149       };
86150     }
86151   }
86152
86153   jresult = (void *)result;
86154   return jresult;
86155 }
86156
86157
86158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
86159   void * jresult ;
86160   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86161   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
86162
86163   arg1 = (Dali::Toolkit::Popup *)jarg1;
86164   {
86165     try {
86166       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
86167     } catch (std::out_of_range& e) {
86168       {
86169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86170       };
86171     } catch (std::exception& e) {
86172       {
86173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86174       };
86175     } catch (Dali::DaliException e) {
86176       {
86177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86178       };
86179     } catch (...) {
86180       {
86181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86182       };
86183     }
86184   }
86185
86186   jresult = (void *)result;
86187   return jresult;
86188 }
86189
86190
86191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
86192   void * jresult ;
86193   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86194   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
86195
86196   arg1 = (Dali::Toolkit::Popup *)jarg1;
86197   {
86198     try {
86199       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
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 (Dali::DaliException e) {
86209       {
86210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86211       };
86212     } catch (...) {
86213       {
86214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86215       };
86216     }
86217   }
86218
86219   jresult = (void *)result;
86220   return jresult;
86221 }
86222
86223
86224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
86225   void * jresult ;
86226   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
86227   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
86228
86229   arg1 = (Dali::Toolkit::Popup *)jarg1;
86230   {
86231     try {
86232       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
86233     } catch (std::out_of_range& e) {
86234       {
86235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86236       };
86237     } catch (std::exception& e) {
86238       {
86239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86240       };
86241     } catch (Dali::DaliException e) {
86242       {
86243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86244       };
86245     } catch (...) {
86246       {
86247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86248       };
86249     }
86250   }
86251
86252   jresult = (void *)result;
86253   return jresult;
86254 }
86255
86256
86257 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
86258   int jresult ;
86259   int result;
86260
86261   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
86262   jresult = (int)result;
86263   return jresult;
86264 }
86265
86266
86267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
86268   int jresult ;
86269   int result;
86270
86271   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
86272   jresult = (int)result;
86273   return jresult;
86274 }
86275
86276
86277 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
86278   int jresult ;
86279   int result;
86280
86281   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
86282   jresult = (int)result;
86283   return jresult;
86284 }
86285
86286
86287 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
86288   int jresult ;
86289   int result;
86290
86291   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
86292   jresult = (int)result;
86293   return jresult;
86294 }
86295
86296
86297 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
86298   int jresult ;
86299   int result;
86300
86301   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
86302   jresult = (int)result;
86303   return jresult;
86304 }
86305
86306
86307 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
86308   int jresult ;
86309   int result;
86310
86311   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
86312   jresult = (int)result;
86313   return jresult;
86314 }
86315
86316
86317 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
86318   int jresult ;
86319   int result;
86320
86321   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
86322   jresult = (int)result;
86323   return jresult;
86324 }
86325
86326
86327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
86328   int jresult ;
86329   int result;
86330
86331   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
86332   jresult = (int)result;
86333   return jresult;
86334 }
86335
86336
86337 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
86338   int jresult ;
86339   int result;
86340
86341   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
86342   jresult = (int)result;
86343   return jresult;
86344 }
86345
86346
86347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
86348   void * jresult ;
86349   Dali::Toolkit::ProgressBar::Property *result = 0 ;
86350
86351   {
86352     try {
86353       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
86354     } catch (std::out_of_range& e) {
86355       {
86356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86357       };
86358     } catch (std::exception& e) {
86359       {
86360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86361       };
86362     } catch (Dali::DaliException e) {
86363       {
86364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86365       };
86366     } catch (...) {
86367       {
86368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86369       };
86370     }
86371   }
86372
86373   jresult = (void *)result;
86374   return jresult;
86375 }
86376
86377
86378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
86379   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
86380
86381   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
86382   {
86383     try {
86384       delete arg1;
86385     } catch (std::out_of_range& e) {
86386       {
86387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86388       };
86389     } catch (std::exception& e) {
86390       {
86391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86392       };
86393     } catch (Dali::DaliException e) {
86394       {
86395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86396       };
86397     } catch (...) {
86398       {
86399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86400       };
86401     }
86402   }
86403
86404 }
86405
86406
86407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
86408   void * jresult ;
86409   Dali::Toolkit::ProgressBar result;
86410
86411   {
86412     try {
86413       result = Dali::Toolkit::ProgressBar::New();
86414     } catch (std::out_of_range& e) {
86415       {
86416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86417       };
86418     } catch (std::exception& e) {
86419       {
86420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86421       };
86422     } catch (Dali::DaliException e) {
86423       {
86424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86425       };
86426     } catch (...) {
86427       {
86428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86429       };
86430     }
86431   }
86432
86433   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
86434   return jresult;
86435 }
86436
86437
86438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
86439   void * jresult ;
86440   Dali::Toolkit::ProgressBar *result = 0 ;
86441
86442   {
86443     try {
86444       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
86445     } catch (std::out_of_range& e) {
86446       {
86447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86448       };
86449     } catch (std::exception& e) {
86450       {
86451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86452       };
86453     } catch (Dali::DaliException e) {
86454       {
86455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86456       };
86457     } catch (...) {
86458       {
86459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86460       };
86461     }
86462   }
86463
86464   jresult = (void *)result;
86465   return jresult;
86466 }
86467
86468
86469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
86470   void * jresult ;
86471   Dali::Toolkit::ProgressBar *arg1 = 0 ;
86472   Dali::Toolkit::ProgressBar *result = 0 ;
86473
86474   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
86475   if (!arg1) {
86476     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
86477     return 0;
86478   }
86479   {
86480     try {
86481       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
86482     } catch (std::out_of_range& e) {
86483       {
86484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86485       };
86486     } catch (std::exception& e) {
86487       {
86488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86489       };
86490     } catch (Dali::DaliException e) {
86491       {
86492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86493       };
86494     } catch (...) {
86495       {
86496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86497       };
86498     }
86499   }
86500
86501   jresult = (void *)result;
86502   return jresult;
86503 }
86504
86505
86506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
86507   void * jresult ;
86508   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
86509   Dali::Toolkit::ProgressBar *arg2 = 0 ;
86510   Dali::Toolkit::ProgressBar *result = 0 ;
86511
86512   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
86513   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
86514   if (!arg2) {
86515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
86516     return 0;
86517   }
86518   {
86519     try {
86520       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
86521     } catch (std::out_of_range& e) {
86522       {
86523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86524       };
86525     } catch (std::exception& e) {
86526       {
86527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86528       };
86529     } catch (Dali::DaliException e) {
86530       {
86531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86532       };
86533     } catch (...) {
86534       {
86535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86536       };
86537     }
86538   }
86539
86540   jresult = (void *)result;
86541   return jresult;
86542 }
86543
86544
86545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
86546   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
86547
86548   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
86549   {
86550     try {
86551       delete arg1;
86552     } catch (std::out_of_range& e) {
86553       {
86554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86555       };
86556     } catch (std::exception& e) {
86557       {
86558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86559       };
86560     } catch (Dali::DaliException e) {
86561       {
86562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86563       };
86564     } catch (...) {
86565       {
86566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86567       };
86568     }
86569   }
86570
86571 }
86572
86573
86574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
86575   void * jresult ;
86576   Dali::BaseHandle arg1 ;
86577   Dali::BaseHandle *argp1 ;
86578   Dali::Toolkit::ProgressBar result;
86579
86580   argp1 = (Dali::BaseHandle *)jarg1;
86581   if (!argp1) {
86582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86583     return 0;
86584   }
86585   arg1 = *argp1;
86586   {
86587     try {
86588       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
86589     } catch (std::out_of_range& e) {
86590       {
86591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86592       };
86593     } catch (std::exception& e) {
86594       {
86595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86596       };
86597     } catch (Dali::DaliException e) {
86598       {
86599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86600       };
86601     } catch (...) {
86602       {
86603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86604       };
86605     }
86606   }
86607
86608   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
86609   return jresult;
86610 }
86611
86612
86613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
86614   void * jresult ;
86615   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
86616   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
86617
86618   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
86619   {
86620     try {
86621       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
86622     } catch (std::out_of_range& e) {
86623       {
86624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86625       };
86626     } catch (std::exception& e) {
86627       {
86628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86629       };
86630     } catch (Dali::DaliException e) {
86631       {
86632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86633       };
86634     } catch (...) {
86635       {
86636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86637       };
86638     }
86639   }
86640
86641   jresult = (void *)result;
86642   return jresult;
86643 }
86644
86645
86646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
86647   void * jresult ;
86648   Dali::Toolkit::GaussianBlurView *result = 0 ;
86649
86650   {
86651     try {
86652       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
86653     } catch (std::out_of_range& e) {
86654       {
86655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86656       };
86657     } catch (std::exception& e) {
86658       {
86659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86660       };
86661     } catch (Dali::DaliException e) {
86662       {
86663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86664       };
86665     } catch (...) {
86666       {
86667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86668       };
86669     }
86670   }
86671
86672   jresult = (void *)result;
86673   return jresult;
86674 }
86675
86676
86677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
86678   void * jresult ;
86679   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
86680   Dali::Toolkit::GaussianBlurView *result = 0 ;
86681
86682   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86683   if (!arg1) {
86684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
86685     return 0;
86686   }
86687   {
86688     try {
86689       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
86690     } catch (std::out_of_range& e) {
86691       {
86692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86693       };
86694     } catch (std::exception& e) {
86695       {
86696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86697       };
86698     } catch (Dali::DaliException e) {
86699       {
86700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86701       };
86702     } catch (...) {
86703       {
86704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86705       };
86706     }
86707   }
86708
86709   jresult = (void *)result;
86710   return jresult;
86711 }
86712
86713
86714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
86715   void * jresult ;
86716   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86717   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
86718   Dali::Toolkit::GaussianBlurView *result = 0 ;
86719
86720   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86721   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
86722   if (!arg2) {
86723     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
86724     return 0;
86725   }
86726   {
86727     try {
86728       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
86729     } catch (std::out_of_range& e) {
86730       {
86731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86732       };
86733     } catch (std::exception& e) {
86734       {
86735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86736       };
86737     } catch (Dali::DaliException e) {
86738       {
86739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86740       };
86741     } catch (...) {
86742       {
86743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86744       };
86745     }
86746   }
86747
86748   jresult = (void *)result;
86749   return jresult;
86750 }
86751
86752
86753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
86754   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86755
86756   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86757   {
86758     try {
86759       delete arg1;
86760     } catch (std::out_of_range& e) {
86761       {
86762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86763       };
86764     } catch (std::exception& e) {
86765       {
86766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86767       };
86768     } catch (Dali::DaliException e) {
86769       {
86770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86771       };
86772     } catch (...) {
86773       {
86774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86775       };
86776     }
86777   }
86778
86779 }
86780
86781
86782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
86783   void * jresult ;
86784   Dali::BaseHandle arg1 ;
86785   Dali::BaseHandle *argp1 ;
86786   Dali::Toolkit::GaussianBlurView result;
86787
86788   argp1 = (Dali::BaseHandle *)jarg1;
86789   if (!argp1) {
86790     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86791     return 0;
86792   }
86793   arg1 = *argp1;
86794   {
86795     try {
86796       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
86797     } catch (std::out_of_range& e) {
86798       {
86799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86800       };
86801     } catch (std::exception& e) {
86802       {
86803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86804       };
86805     } catch (Dali::DaliException e) {
86806       {
86807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86808       };
86809     } catch (...) {
86810       {
86811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86812       };
86813     }
86814   }
86815
86816   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
86817   return jresult;
86818 }
86819
86820
86821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
86822   void * jresult ;
86823   Dali::Toolkit::GaussianBlurView result;
86824
86825   {
86826     try {
86827       result = Dali::Toolkit::GaussianBlurView::New();
86828     } catch (std::out_of_range& e) {
86829       {
86830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86831       };
86832     } catch (std::exception& e) {
86833       {
86834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86835       };
86836     } catch (Dali::DaliException e) {
86837       {
86838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86839       };
86840     } catch (...) {
86841       {
86842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86843       };
86844     }
86845   }
86846
86847   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
86848   return jresult;
86849 }
86850
86851
86852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
86853   void * jresult ;
86854   unsigned int arg1 ;
86855   float arg2 ;
86856   Dali::Pixel::Format arg3 ;
86857   float arg4 ;
86858   float arg5 ;
86859   bool arg6 ;
86860   Dali::Toolkit::GaussianBlurView result;
86861
86862   arg1 = (unsigned int)jarg1;
86863   arg2 = (float)jarg2;
86864   arg3 = (Dali::Pixel::Format)jarg3;
86865   arg4 = (float)jarg4;
86866   arg5 = (float)jarg5;
86867   arg6 = jarg6 ? true : false;
86868   {
86869     try {
86870       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
86871     } catch (std::out_of_range& e) {
86872       {
86873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86874       };
86875     } catch (std::exception& e) {
86876       {
86877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86878       };
86879     } catch (Dali::DaliException e) {
86880       {
86881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86882       };
86883     } catch (...) {
86884       {
86885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86886       };
86887     }
86888   }
86889
86890   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
86891   return jresult;
86892 }
86893
86894
86895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
86896   void * jresult ;
86897   unsigned int arg1 ;
86898   float arg2 ;
86899   Dali::Pixel::Format arg3 ;
86900   float arg4 ;
86901   float arg5 ;
86902   Dali::Toolkit::GaussianBlurView result;
86903
86904   arg1 = (unsigned int)jarg1;
86905   arg2 = (float)jarg2;
86906   arg3 = (Dali::Pixel::Format)jarg3;
86907   arg4 = (float)jarg4;
86908   arg5 = (float)jarg5;
86909   {
86910     try {
86911       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
86912     } catch (std::out_of_range& e) {
86913       {
86914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86915       };
86916     } catch (std::exception& e) {
86917       {
86918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86919       };
86920     } catch (Dali::DaliException e) {
86921       {
86922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86923       };
86924     } catch (...) {
86925       {
86926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86927       };
86928     }
86929   }
86930
86931   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
86932   return jresult;
86933 }
86934
86935
86936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
86937   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86938   Dali::Actor arg2 ;
86939   Dali::Actor *argp2 ;
86940
86941   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86942   argp2 = (Dali::Actor *)jarg2;
86943   if (!argp2) {
86944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86945     return ;
86946   }
86947   arg2 = *argp2;
86948   {
86949     try {
86950       (arg1)->Add(arg2);
86951     } catch (std::out_of_range& e) {
86952       {
86953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86954       };
86955     } catch (std::exception& e) {
86956       {
86957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86958       };
86959     } catch (Dali::DaliException e) {
86960       {
86961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86962       };
86963     } catch (...) {
86964       {
86965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86966       };
86967     }
86968   }
86969
86970 }
86971
86972
86973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
86974   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
86975   Dali::Actor arg2 ;
86976   Dali::Actor *argp2 ;
86977
86978   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
86979   argp2 = (Dali::Actor *)jarg2;
86980   if (!argp2) {
86981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86982     return ;
86983   }
86984   arg2 = *argp2;
86985   {
86986     try {
86987       (arg1)->Remove(arg2);
86988     } catch (std::out_of_range& e) {
86989       {
86990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86991       };
86992     } catch (std::exception& e) {
86993       {
86994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86995       };
86996     } catch (Dali::DaliException e) {
86997       {
86998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86999       };
87000     } catch (...) {
87001       {
87002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87003       };
87004     }
87005   }
87006
87007 }
87008
87009
87010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
87011   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87012
87013   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87014   {
87015     try {
87016       (arg1)->Activate();
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 (Dali::DaliException e) {
87026       {
87027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87028       };
87029     } catch (...) {
87030       {
87031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87032       };
87033     }
87034   }
87035
87036 }
87037
87038
87039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
87040   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87041
87042   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87043   {
87044     try {
87045       (arg1)->ActivateOnce();
87046     } catch (std::out_of_range& e) {
87047       {
87048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87049       };
87050     } catch (std::exception& e) {
87051       {
87052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87053       };
87054     } catch (Dali::DaliException e) {
87055       {
87056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87057       };
87058     } catch (...) {
87059       {
87060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87061       };
87062     }
87063   }
87064
87065 }
87066
87067
87068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
87069   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87070
87071   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87072   {
87073     try {
87074       (arg1)->Deactivate();
87075     } catch (std::out_of_range& e) {
87076       {
87077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87078       };
87079     } catch (std::exception& e) {
87080       {
87081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87082       };
87083     } catch (Dali::DaliException e) {
87084       {
87085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87086       };
87087     } catch (...) {
87088       {
87089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87090       };
87091     }
87092   }
87093
87094 }
87095
87096
87097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
87098   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87099   Dali::Texture arg2 ;
87100   Dali::FrameBuffer arg3 ;
87101   Dali::Texture *argp2 ;
87102   Dali::FrameBuffer *argp3 ;
87103
87104   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87105   argp2 = (Dali::Texture *)jarg2;
87106   if (!argp2) {
87107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
87108     return ;
87109   }
87110   arg2 = *argp2;
87111   argp3 = (Dali::FrameBuffer *)jarg3;
87112   if (!argp3) {
87113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
87114     return ;
87115   }
87116   arg3 = *argp3;
87117   {
87118     try {
87119       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
87120     } catch (std::out_of_range& e) {
87121       {
87122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87123       };
87124     } catch (std::exception& e) {
87125       {
87126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87127       };
87128     } catch (Dali::DaliException e) {
87129       {
87130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87131       };
87132     } catch (...) {
87133       {
87134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87135       };
87136     }
87137   }
87138
87139 }
87140
87141
87142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
87143   int jresult ;
87144   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87145   Dali::Property::Index result;
87146
87147   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87148   {
87149     try {
87150       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
87151     } catch (std::out_of_range& e) {
87152       {
87153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87154       };
87155     } catch (std::exception& e) {
87156       {
87157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87158       };
87159     } catch (Dali::DaliException e) {
87160       {
87161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87162       };
87163     } catch (...) {
87164       {
87165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87166       };
87167     }
87168   }
87169
87170   jresult = result;
87171   return jresult;
87172 }
87173
87174
87175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
87176   void * jresult ;
87177   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87178   Dali::FrameBuffer result;
87179
87180   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87181   {
87182     try {
87183       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
87184     } catch (std::out_of_range& e) {
87185       {
87186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87187       };
87188     } catch (std::exception& e) {
87189       {
87190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87191       };
87192     } catch (Dali::DaliException e) {
87193       {
87194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87195       };
87196     } catch (...) {
87197       {
87198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87199       };
87200     }
87201   }
87202
87203   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
87204   return jresult;
87205 }
87206
87207
87208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
87209   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87210   Dali::Vector4 *arg2 = 0 ;
87211
87212   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87213   arg2 = (Dali::Vector4 *)jarg2;
87214   if (!arg2) {
87215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
87216     return ;
87217   }
87218   {
87219     try {
87220       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
87221     } catch (std::out_of_range& e) {
87222       {
87223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87224       };
87225     } catch (std::exception& e) {
87226       {
87227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87228       };
87229     } catch (Dali::DaliException e) {
87230       {
87231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87232       };
87233     } catch (...) {
87234       {
87235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87236       };
87237     }
87238   }
87239
87240 }
87241
87242
87243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
87244   void * jresult ;
87245   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87246   Dali::Vector4 result;
87247
87248   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87249   {
87250     try {
87251       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
87252     } catch (std::out_of_range& e) {
87253       {
87254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87255       };
87256     } catch (std::exception& e) {
87257       {
87258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87259       };
87260     } catch (Dali::DaliException e) {
87261       {
87262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87263       };
87264     } catch (...) {
87265       {
87266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87267       };
87268     }
87269   }
87270
87271   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
87272   return jresult;
87273 }
87274
87275
87276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
87277   void * jresult ;
87278   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
87279   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
87280
87281   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
87282   {
87283     try {
87284       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
87285     } catch (std::out_of_range& e) {
87286       {
87287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87288       };
87289     } catch (std::exception& e) {
87290       {
87291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87292       };
87293     } catch (Dali::DaliException e) {
87294       {
87295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87296       };
87297     } catch (...) {
87298       {
87299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87300       };
87301     }
87302   }
87303
87304   jresult = (void *)result;
87305   return jresult;
87306 }
87307
87308
87309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
87310   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
87311
87312   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
87313   {
87314     try {
87315       delete arg1;
87316     } catch (std::out_of_range& e) {
87317       {
87318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87319       };
87320     } catch (std::exception& e) {
87321       {
87322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87323       };
87324     } catch (Dali::DaliException e) {
87325       {
87326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87327       };
87328     } catch (...) {
87329       {
87330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87331       };
87332     }
87333   }
87334
87335 }
87336
87337
87338 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
87339   unsigned int jresult ;
87340   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
87341   unsigned int result;
87342
87343   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
87344   {
87345     try {
87346       result = (unsigned int)(arg1)->GetNumberOfPages();
87347     } catch (std::out_of_range& e) {
87348       {
87349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87350       };
87351     } catch (std::exception& e) {
87352       {
87353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87354       };
87355     } catch (Dali::DaliException e) {
87356       {
87357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87358       };
87359     } catch (...) {
87360       {
87361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87362       };
87363     }
87364   }
87365
87366   jresult = result;
87367   return jresult;
87368 }
87369
87370
87371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
87372   void * jresult ;
87373   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
87374   unsigned int arg2 ;
87375   Dali::Texture result;
87376
87377   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
87378   arg2 = (unsigned int)jarg2;
87379   {
87380     try {
87381       result = (arg1)->NewPage(arg2);
87382     } catch (std::out_of_range& e) {
87383       {
87384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87385       };
87386     } catch (std::exception& e) {
87387       {
87388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87389       };
87390     } catch (Dali::DaliException e) {
87391       {
87392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87393       };
87394     } catch (...) {
87395       {
87396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87397       };
87398     }
87399   }
87400
87401   jresult = new Dali::Texture((const Dali::Texture &)result);
87402   return jresult;
87403 }
87404
87405
87406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
87407   int jresult ;
87408   int result;
87409
87410   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
87411   jresult = (int)result;
87412   return jresult;
87413 }
87414
87415
87416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
87417   int jresult ;
87418   int result;
87419
87420   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
87421   jresult = (int)result;
87422   return jresult;
87423 }
87424
87425
87426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
87427   int jresult ;
87428   int result;
87429
87430   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
87431   jresult = (int)result;
87432   return jresult;
87433 }
87434
87435
87436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
87437   void * jresult ;
87438   Dali::Toolkit::PageTurnView::Property *result = 0 ;
87439
87440   {
87441     try {
87442       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
87443     } catch (std::out_of_range& e) {
87444       {
87445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87446       };
87447     } catch (std::exception& e) {
87448       {
87449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87450       };
87451     } catch (Dali::DaliException e) {
87452       {
87453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87454       };
87455     } catch (...) {
87456       {
87457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87458       };
87459     }
87460   }
87461
87462   jresult = (void *)result;
87463   return jresult;
87464 }
87465
87466
87467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
87468   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
87469
87470   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
87471   {
87472     try {
87473       delete arg1;
87474     } catch (std::out_of_range& e) {
87475       {
87476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87477       };
87478     } catch (std::exception& e) {
87479       {
87480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87481       };
87482     } catch (Dali::DaliException e) {
87483       {
87484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87485       };
87486     } catch (...) {
87487       {
87488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87489       };
87490     }
87491   }
87492
87493 }
87494
87495
87496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
87497   void * jresult ;
87498   Dali::Toolkit::PageTurnView *result = 0 ;
87499
87500   {
87501     try {
87502       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
87503     } catch (std::out_of_range& e) {
87504       {
87505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87506       };
87507     } catch (std::exception& e) {
87508       {
87509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87510       };
87511     } catch (Dali::DaliException e) {
87512       {
87513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87514       };
87515     } catch (...) {
87516       {
87517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87518       };
87519     }
87520   }
87521
87522   jresult = (void *)result;
87523   return jresult;
87524 }
87525
87526
87527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
87528   void * jresult ;
87529   Dali::Toolkit::PageTurnView *arg1 = 0 ;
87530   Dali::Toolkit::PageTurnView *result = 0 ;
87531
87532   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87533   if (!arg1) {
87534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
87535     return 0;
87536   }
87537   {
87538     try {
87539       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
87540     } catch (std::out_of_range& e) {
87541       {
87542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87543       };
87544     } catch (std::exception& e) {
87545       {
87546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87547       };
87548     } catch (Dali::DaliException e) {
87549       {
87550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87551       };
87552     } catch (...) {
87553       {
87554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87555       };
87556     }
87557   }
87558
87559   jresult = (void *)result;
87560   return jresult;
87561 }
87562
87563
87564 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
87565   void * jresult ;
87566   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
87567   Dali::Toolkit::PageTurnView *arg2 = 0 ;
87568   Dali::Toolkit::PageTurnView *result = 0 ;
87569
87570   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87571   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
87572   if (!arg2) {
87573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
87574     return 0;
87575   }
87576   {
87577     try {
87578       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
87579     } catch (std::out_of_range& e) {
87580       {
87581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87582       };
87583     } catch (std::exception& e) {
87584       {
87585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87586       };
87587     } catch (Dali::DaliException e) {
87588       {
87589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87590       };
87591     } catch (...) {
87592       {
87593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87594       };
87595     }
87596   }
87597
87598   jresult = (void *)result;
87599   return jresult;
87600 }
87601
87602
87603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
87604   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
87605
87606   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87607   {
87608     try {
87609       delete arg1;
87610     } catch (std::out_of_range& e) {
87611       {
87612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87613       };
87614     } catch (std::exception& e) {
87615       {
87616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87617       };
87618     } catch (Dali::DaliException e) {
87619       {
87620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87621       };
87622     } catch (...) {
87623       {
87624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87625       };
87626     }
87627   }
87628
87629 }
87630
87631
87632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
87633   void * jresult ;
87634   Dali::BaseHandle arg1 ;
87635   Dali::BaseHandle *argp1 ;
87636   Dali::Toolkit::PageTurnView result;
87637
87638   argp1 = (Dali::BaseHandle *)jarg1;
87639   if (!argp1) {
87640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87641     return 0;
87642   }
87643   arg1 = *argp1;
87644   {
87645     try {
87646       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
87647     } catch (std::out_of_range& e) {
87648       {
87649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87650       };
87651     } catch (std::exception& e) {
87652       {
87653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87654       };
87655     } catch (Dali::DaliException e) {
87656       {
87657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87658       };
87659     } catch (...) {
87660       {
87661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87662       };
87663     }
87664   }
87665
87666   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
87667   return jresult;
87668 }
87669
87670
87671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
87672   void * jresult ;
87673   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
87674   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
87675
87676   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87677   {
87678     try {
87679       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
87680     } catch (std::out_of_range& e) {
87681       {
87682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87683       };
87684     } catch (std::exception& e) {
87685       {
87686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87687       };
87688     } catch (Dali::DaliException e) {
87689       {
87690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87691       };
87692     } catch (...) {
87693       {
87694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87695       };
87696     }
87697   }
87698
87699   jresult = (void *)result;
87700   return jresult;
87701 }
87702
87703
87704 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
87705   void * jresult ;
87706   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
87707   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
87708
87709   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87710   {
87711     try {
87712       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
87713     } catch (std::out_of_range& e) {
87714       {
87715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87716       };
87717     } catch (std::exception& e) {
87718       {
87719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87720       };
87721     } catch (Dali::DaliException e) {
87722       {
87723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87724       };
87725     } catch (...) {
87726       {
87727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87728       };
87729     }
87730   }
87731
87732   jresult = (void *)result;
87733   return jresult;
87734 }
87735
87736
87737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
87738   void * jresult ;
87739   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
87740   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
87741
87742   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87743   {
87744     try {
87745       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
87746     } catch (std::out_of_range& e) {
87747       {
87748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87749       };
87750     } catch (std::exception& e) {
87751       {
87752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87753       };
87754     } catch (Dali::DaliException e) {
87755       {
87756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87757       };
87758     } catch (...) {
87759       {
87760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87761       };
87762     }
87763   }
87764
87765   jresult = (void *)result;
87766   return jresult;
87767 }
87768
87769
87770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
87771   void * jresult ;
87772   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
87773   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
87774
87775   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
87776   {
87777     try {
87778       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
87779     } catch (std::out_of_range& e) {
87780       {
87781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87782       };
87783     } catch (std::exception& e) {
87784       {
87785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87786       };
87787     } catch (Dali::DaliException e) {
87788       {
87789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87790       };
87791     } catch (...) {
87792       {
87793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87794       };
87795     }
87796   }
87797
87798   jresult = (void *)result;
87799   return jresult;
87800 }
87801
87802
87803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
87804   void * jresult ;
87805   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
87806
87807   {
87808     try {
87809       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
87810     } catch (std::out_of_range& e) {
87811       {
87812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87813       };
87814     } catch (std::exception& e) {
87815       {
87816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87817       };
87818     } catch (Dali::DaliException e) {
87819       {
87820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87821       };
87822     } catch (...) {
87823       {
87824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87825       };
87826     }
87827   }
87828
87829   jresult = (void *)result;
87830   return jresult;
87831 }
87832
87833
87834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
87835   void * jresult ;
87836   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
87837   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
87838
87839   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
87840   if (!arg1) {
87841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
87842     return 0;
87843   }
87844   {
87845     try {
87846       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
87847     } catch (std::out_of_range& e) {
87848       {
87849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87850       };
87851     } catch (std::exception& e) {
87852       {
87853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87854       };
87855     } catch (Dali::DaliException e) {
87856       {
87857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87858       };
87859     } catch (...) {
87860       {
87861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87862       };
87863     }
87864   }
87865
87866   jresult = (void *)result;
87867   return jresult;
87868 }
87869
87870
87871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
87872   void * jresult ;
87873   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
87874   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
87875   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
87876
87877   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
87878   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
87879   if (!arg2) {
87880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
87881     return 0;
87882   }
87883   {
87884     try {
87885       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
87886     } catch (std::out_of_range& e) {
87887       {
87888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87889       };
87890     } catch (std::exception& e) {
87891       {
87892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87893       };
87894     } catch (Dali::DaliException e) {
87895       {
87896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87897       };
87898     } catch (...) {
87899       {
87900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87901       };
87902     }
87903   }
87904
87905   jresult = (void *)result;
87906   return jresult;
87907 }
87908
87909
87910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
87911   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
87912
87913   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
87914   {
87915     try {
87916       delete arg1;
87917     } catch (std::out_of_range& e) {
87918       {
87919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87920       };
87921     } catch (std::exception& e) {
87922       {
87923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87924       };
87925     } catch (Dali::DaliException e) {
87926       {
87927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87928       };
87929     } catch (...) {
87930       {
87931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87932       };
87933     }
87934   }
87935
87936 }
87937
87938
87939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
87940   void * jresult ;
87941   Dali::Toolkit::PageFactory *arg1 = 0 ;
87942   Dali::Vector2 *arg2 = 0 ;
87943   Dali::Toolkit::PageTurnLandscapeView result;
87944
87945   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
87946   if (!arg1) {
87947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
87948     return 0;
87949   }
87950   arg2 = (Dali::Vector2 *)jarg2;
87951   if (!arg2) {
87952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
87953     return 0;
87954   }
87955   {
87956     try {
87957       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
87958     } catch (std::out_of_range& e) {
87959       {
87960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87961       };
87962     } catch (std::exception& e) {
87963       {
87964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87965       };
87966     } catch (Dali::DaliException e) {
87967       {
87968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87969       };
87970     } catch (...) {
87971       {
87972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87973       };
87974     }
87975   }
87976
87977   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
87978   return jresult;
87979 }
87980
87981
87982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
87983   void * jresult ;
87984   Dali::BaseHandle arg1 ;
87985   Dali::BaseHandle *argp1 ;
87986   Dali::Toolkit::PageTurnLandscapeView result;
87987
87988   argp1 = (Dali::BaseHandle *)jarg1;
87989   if (!argp1) {
87990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
87991     return 0;
87992   }
87993   arg1 = *argp1;
87994   {
87995     try {
87996       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
87997     } catch (std::out_of_range& e) {
87998       {
87999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88000       };
88001     } catch (std::exception& e) {
88002       {
88003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88004       };
88005     } catch (Dali::DaliException e) {
88006       {
88007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88008       };
88009     } catch (...) {
88010       {
88011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88012       };
88013     }
88014   }
88015
88016   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
88017   return jresult;
88018 }
88019
88020
88021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
88022   void * jresult ;
88023   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
88024
88025   {
88026     try {
88027       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
88028     } catch (std::out_of_range& e) {
88029       {
88030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88031       };
88032     } catch (std::exception& e) {
88033       {
88034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88035       };
88036     } catch (Dali::DaliException e) {
88037       {
88038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88039       };
88040     } catch (...) {
88041       {
88042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88043       };
88044     }
88045   }
88046
88047   jresult = (void *)result;
88048   return jresult;
88049 }
88050
88051
88052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
88053   void * jresult ;
88054   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
88055   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
88056
88057   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
88058   if (!arg1) {
88059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
88060     return 0;
88061   }
88062   {
88063     try {
88064       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
88065     } catch (std::out_of_range& e) {
88066       {
88067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88068       };
88069     } catch (std::exception& e) {
88070       {
88071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88072       };
88073     } catch (Dali::DaliException e) {
88074       {
88075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88076       };
88077     } catch (...) {
88078       {
88079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88080       };
88081     }
88082   }
88083
88084   jresult = (void *)result;
88085   return jresult;
88086 }
88087
88088
88089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
88090   void * jresult ;
88091   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
88092   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
88093   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
88094
88095   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
88096   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
88097   if (!arg2) {
88098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
88099     return 0;
88100   }
88101   {
88102     try {
88103       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
88104     } catch (std::out_of_range& e) {
88105       {
88106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88107       };
88108     } catch (std::exception& e) {
88109       {
88110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88111       };
88112     } catch (Dali::DaliException e) {
88113       {
88114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88115       };
88116     } catch (...) {
88117       {
88118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88119       };
88120     }
88121   }
88122
88123   jresult = (void *)result;
88124   return jresult;
88125 }
88126
88127
88128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
88129   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
88130
88131   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
88132   {
88133     try {
88134       delete arg1;
88135     } catch (std::out_of_range& e) {
88136       {
88137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88138       };
88139     } catch (std::exception& e) {
88140       {
88141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88142       };
88143     } catch (Dali::DaliException e) {
88144       {
88145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88146       };
88147     } catch (...) {
88148       {
88149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88150       };
88151     }
88152   }
88153
88154 }
88155
88156
88157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
88158   void * jresult ;
88159   Dali::Toolkit::PageFactory *arg1 = 0 ;
88160   Dali::Vector2 *arg2 = 0 ;
88161   Dali::Toolkit::PageTurnPortraitView result;
88162
88163   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
88164   if (!arg1) {
88165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
88166     return 0;
88167   }
88168   arg2 = (Dali::Vector2 *)jarg2;
88169   if (!arg2) {
88170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
88171     return 0;
88172   }
88173   {
88174     try {
88175       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
88176     } catch (std::out_of_range& e) {
88177       {
88178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88179       };
88180     } catch (std::exception& e) {
88181       {
88182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88183       };
88184     } catch (Dali::DaliException e) {
88185       {
88186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88187       };
88188     } catch (...) {
88189       {
88190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88191       };
88192     }
88193   }
88194
88195   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
88196   return jresult;
88197 }
88198
88199
88200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
88201   void * jresult ;
88202   Dali::BaseHandle arg1 ;
88203   Dali::BaseHandle *argp1 ;
88204   Dali::Toolkit::PageTurnPortraitView result;
88205
88206   argp1 = (Dali::BaseHandle *)jarg1;
88207   if (!argp1) {
88208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88209     return 0;
88210   }
88211   arg1 = *argp1;
88212   {
88213     try {
88214       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
88215     } catch (std::out_of_range& e) {
88216       {
88217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88218       };
88219     } catch (std::exception& e) {
88220       {
88221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88222       };
88223     } catch (Dali::DaliException e) {
88224       {
88225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88226       };
88227     } catch (...) {
88228       {
88229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88230       };
88231     }
88232   }
88233
88234   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
88235   return jresult;
88236 }
88237
88238
88239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
88240   int jresult ;
88241   int result;
88242
88243   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
88244   jresult = (int)result;
88245   return jresult;
88246 }
88247
88248
88249 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
88250   int jresult ;
88251   int result;
88252
88253   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
88254   jresult = (int)result;
88255   return jresult;
88256 }
88257
88258
88259 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
88260   int jresult ;
88261   int result;
88262
88263   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
88264   jresult = (int)result;
88265   return jresult;
88266 }
88267
88268
88269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
88270   void * jresult ;
88271   Dali::Toolkit::ToggleButton::Property *result = 0 ;
88272
88273   {
88274     try {
88275       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
88276     } catch (std::out_of_range& e) {
88277       {
88278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88279       };
88280     } catch (std::exception& e) {
88281       {
88282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88283       };
88284     } catch (Dali::DaliException e) {
88285       {
88286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88287       };
88288     } catch (...) {
88289       {
88290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88291       };
88292     }
88293   }
88294
88295   jresult = (void *)result;
88296   return jresult;
88297 }
88298
88299
88300 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
88301   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
88302
88303   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
88304   {
88305     try {
88306       delete arg1;
88307     } catch (std::out_of_range& e) {
88308       {
88309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88310       };
88311     } catch (std::exception& e) {
88312       {
88313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88314       };
88315     } catch (Dali::DaliException e) {
88316       {
88317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88318       };
88319     } catch (...) {
88320       {
88321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88322       };
88323     }
88324   }
88325
88326 }
88327
88328
88329 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
88330   void * jresult ;
88331   Dali::Toolkit::ToggleButton *result = 0 ;
88332
88333   {
88334     try {
88335       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
88336     } catch (std::out_of_range& e) {
88337       {
88338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88339       };
88340     } catch (std::exception& e) {
88341       {
88342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88343       };
88344     } catch (Dali::DaliException e) {
88345       {
88346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88347       };
88348     } catch (...) {
88349       {
88350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88351       };
88352     }
88353   }
88354
88355   jresult = (void *)result;
88356   return jresult;
88357 }
88358
88359
88360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
88361   void * jresult ;
88362   Dali::Toolkit::ToggleButton *arg1 = 0 ;
88363   Dali::Toolkit::ToggleButton *result = 0 ;
88364
88365   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
88366   if (!arg1) {
88367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
88368     return 0;
88369   }
88370   {
88371     try {
88372       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
88373     } catch (std::out_of_range& e) {
88374       {
88375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88376       };
88377     } catch (std::exception& e) {
88378       {
88379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88380       };
88381     } catch (Dali::DaliException e) {
88382       {
88383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88384       };
88385     } catch (...) {
88386       {
88387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88388       };
88389     }
88390   }
88391
88392   jresult = (void *)result;
88393   return jresult;
88394 }
88395
88396
88397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
88398   void * jresult ;
88399   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
88400   Dali::Toolkit::ToggleButton *arg2 = 0 ;
88401   Dali::Toolkit::ToggleButton *result = 0 ;
88402
88403   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
88404   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
88405   if (!arg2) {
88406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
88407     return 0;
88408   }
88409   {
88410     try {
88411       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
88412     } catch (std::out_of_range& e) {
88413       {
88414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88415       };
88416     } catch (std::exception& e) {
88417       {
88418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88419       };
88420     } catch (Dali::DaliException e) {
88421       {
88422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88423       };
88424     } catch (...) {
88425       {
88426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88427       };
88428     }
88429   }
88430
88431   jresult = (void *)result;
88432   return jresult;
88433 }
88434
88435
88436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
88437   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
88438
88439   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
88440   {
88441     try {
88442       delete arg1;
88443     } catch (std::out_of_range& e) {
88444       {
88445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88446       };
88447     } catch (std::exception& e) {
88448       {
88449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88450       };
88451     } catch (Dali::DaliException e) {
88452       {
88453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88454       };
88455     } catch (...) {
88456       {
88457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88458       };
88459     }
88460   }
88461
88462 }
88463
88464
88465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
88466   void * jresult ;
88467   Dali::Toolkit::ToggleButton result;
88468
88469   {
88470     try {
88471       result = Dali::Toolkit::ToggleButton::New();
88472     } catch (std::out_of_range& e) {
88473       {
88474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88475       };
88476     } catch (std::exception& e) {
88477       {
88478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88479       };
88480     } catch (Dali::DaliException e) {
88481       {
88482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88483       };
88484     } catch (...) {
88485       {
88486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88487       };
88488     }
88489   }
88490
88491   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
88492   return jresult;
88493 }
88494
88495
88496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
88497   void * jresult ;
88498   Dali::BaseHandle arg1 ;
88499   Dali::BaseHandle *argp1 ;
88500   Dali::Toolkit::ToggleButton result;
88501
88502   argp1 = (Dali::BaseHandle *)jarg1;
88503   if (!argp1) {
88504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
88505     return 0;
88506   }
88507   arg1 = *argp1;
88508   {
88509     try {
88510       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
88511     } catch (std::out_of_range& e) {
88512       {
88513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88514       };
88515     } catch (std::exception& e) {
88516       {
88517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88518       };
88519     } catch (Dali::DaliException e) {
88520       {
88521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88522       };
88523     } catch (...) {
88524       {
88525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88526       };
88527     }
88528   }
88529
88530   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
88531   return jresult;
88532 }
88533
88534
88535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
88536   void * jresult ;
88537   Dali::Toolkit::Visual::Base *result = 0 ;
88538
88539   {
88540     try {
88541       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
88542     } catch (std::out_of_range& e) {
88543       {
88544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88545       };
88546     } catch (std::exception& e) {
88547       {
88548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88549       };
88550     } catch (Dali::DaliException e) {
88551       {
88552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88553       };
88554     } catch (...) {
88555       {
88556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88557       };
88558     }
88559   }
88560
88561   jresult = (void *)result;
88562   return jresult;
88563 }
88564
88565
88566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
88567   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88568
88569   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88570   {
88571     try {
88572       delete arg1;
88573     } catch (std::out_of_range& e) {
88574       {
88575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88576       };
88577     } catch (std::exception& e) {
88578       {
88579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88580       };
88581     } catch (Dali::DaliException e) {
88582       {
88583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88584       };
88585     } catch (...) {
88586       {
88587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88588       };
88589     }
88590   }
88591
88592 }
88593
88594
88595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
88596   void * jresult ;
88597   Dali::Toolkit::Visual::Base *arg1 = 0 ;
88598   Dali::Toolkit::Visual::Base *result = 0 ;
88599
88600   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88601   if (!arg1) {
88602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
88603     return 0;
88604   }
88605   {
88606     try {
88607       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
88608     } catch (std::out_of_range& e) {
88609       {
88610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88611       };
88612     } catch (std::exception& e) {
88613       {
88614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88615       };
88616     } catch (Dali::DaliException e) {
88617       {
88618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88619       };
88620     } catch (...) {
88621       {
88622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88623       };
88624     }
88625   }
88626
88627   jresult = (void *)result;
88628   return jresult;
88629 }
88630
88631
88632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
88633   void * jresult ;
88634   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88635   Dali::Toolkit::Visual::Base *arg2 = 0 ;
88636   Dali::Toolkit::Visual::Base *result = 0 ;
88637
88638   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88639   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
88640   if (!arg2) {
88641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
88642     return 0;
88643   }
88644   {
88645     try {
88646       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
88647     } catch (std::out_of_range& e) {
88648       {
88649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88650       };
88651     } catch (std::exception& e) {
88652       {
88653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88654       };
88655     } catch (Dali::DaliException e) {
88656       {
88657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88658       };
88659     } catch (...) {
88660       {
88661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88662       };
88663     }
88664   }
88665
88666   jresult = (void *)result;
88667   return jresult;
88668 }
88669
88670
88671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
88672   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88673   std::string *arg2 = 0 ;
88674
88675   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88676   if (!jarg2) {
88677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
88678     return ;
88679   }
88680   std::string arg2_str(jarg2);
88681   arg2 = &arg2_str;
88682   {
88683     try {
88684       (arg1)->SetName((std::string const &)*arg2);
88685     } catch (std::out_of_range& e) {
88686       {
88687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88688       };
88689     } catch (std::exception& e) {
88690       {
88691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88692       };
88693     } catch (Dali::DaliException e) {
88694       {
88695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88696       };
88697     } catch (...) {
88698       {
88699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88700       };
88701     }
88702   }
88703
88704
88705   //argout typemap for const std::string&
88706
88707 }
88708
88709
88710 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
88711   char * jresult ;
88712   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88713   std::string *result = 0 ;
88714
88715   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88716   {
88717     try {
88718       result = (std::string *) &(arg1)->GetName();
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 (Dali::DaliException e) {
88728       {
88729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88730       };
88731     } catch (...) {
88732       {
88733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88734       };
88735     }
88736   }
88737
88738   jresult = SWIG_csharp_string_callback(result->c_str());
88739   return jresult;
88740 }
88741
88742
88743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
88744   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88745   Dali::Property::Map *arg2 = 0 ;
88746   Dali::Size arg3 ;
88747   Dali::Size *argp3 ;
88748
88749   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88750   arg2 = (Dali::Property::Map *)jarg2;
88751   if (!arg2) {
88752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
88753     return ;
88754   }
88755   argp3 = (Dali::Size *)jarg3;
88756   if (!argp3) {
88757     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
88758     return ;
88759   }
88760   arg3 = *argp3;
88761   {
88762     try {
88763       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
88764     } catch (std::out_of_range& e) {
88765       {
88766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88767       };
88768     } catch (std::exception& e) {
88769       {
88770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88771       };
88772     } catch (Dali::DaliException e) {
88773       {
88774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88775       };
88776     } catch (...) {
88777       {
88778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88779       };
88780     }
88781   }
88782
88783 }
88784
88785
88786 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
88787   float jresult ;
88788   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88789   float arg2 ;
88790   float result;
88791
88792   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88793   arg2 = (float)jarg2;
88794   {
88795     try {
88796       result = (float)(arg1)->GetHeightForWidth(arg2);
88797     } catch (std::out_of_range& e) {
88798       {
88799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88800       };
88801     } catch (std::exception& e) {
88802       {
88803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88804       };
88805     } catch (Dali::DaliException e) {
88806       {
88807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88808       };
88809     } catch (...) {
88810       {
88811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88812       };
88813     }
88814   }
88815
88816   jresult = result;
88817   return jresult;
88818 }
88819
88820
88821 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
88822   float jresult ;
88823   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88824   float arg2 ;
88825   float result;
88826
88827   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88828   arg2 = (float)jarg2;
88829   {
88830     try {
88831       result = (float)(arg1)->GetWidthForHeight(arg2);
88832     } catch (std::out_of_range& e) {
88833       {
88834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88835       };
88836     } catch (std::exception& e) {
88837       {
88838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88839       };
88840     } catch (Dali::DaliException e) {
88841       {
88842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88843       };
88844     } catch (...) {
88845       {
88846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88847       };
88848     }
88849   }
88850
88851   jresult = result;
88852   return jresult;
88853 }
88854
88855
88856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
88857   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88858   Dali::Vector2 *arg2 = 0 ;
88859
88860   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88861   arg2 = (Dali::Vector2 *)jarg2;
88862   if (!arg2) {
88863     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
88864     return ;
88865   }
88866   {
88867     try {
88868       (arg1)->GetNaturalSize(*arg2);
88869     } catch (std::out_of_range& e) {
88870       {
88871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88872       };
88873     } catch (std::exception& e) {
88874       {
88875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88876       };
88877     } catch (Dali::DaliException e) {
88878       {
88879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88880       };
88881     } catch (...) {
88882       {
88883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88884       };
88885     }
88886   }
88887
88888 }
88889
88890
88891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
88892   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88893   float arg2 ;
88894
88895   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88896   arg2 = (int)jarg2;
88897   {
88898     try {
88899       (arg1)->SetDepthIndex(arg2);
88900     } catch (std::out_of_range& e) {
88901       {
88902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88903       };
88904     } catch (std::exception& e) {
88905       {
88906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88907       };
88908     } catch (Dali::DaliException e) {
88909       {
88910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88911       };
88912     } catch (...) {
88913       {
88914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88915       };
88916     }
88917   }
88918
88919 }
88920
88921
88922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
88923   int jresult ;
88924   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88925   int result;
88926
88927   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88928   {
88929     try {
88930       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
88931     } catch (std::out_of_range& e) {
88932       {
88933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88934       };
88935     } catch (std::exception& e) {
88936       {
88937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88938       };
88939     } catch (Dali::DaliException e) {
88940       {
88941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88942       };
88943     } catch (...) {
88944       {
88945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88946       };
88947     }
88948   }
88949
88950   jresult = result;
88951   return jresult;
88952 }
88953
88954
88955 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
88956   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
88957   Dali::Property::Map *arg2 = 0 ;
88958
88959   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
88960   arg2 = (Dali::Property::Map *)jarg2;
88961   if (!arg2) {
88962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
88963     return ;
88964   }
88965   {
88966     try {
88967       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
88968     } catch (std::out_of_range& e) {
88969       {
88970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88971       };
88972     } catch (std::exception& e) {
88973       {
88974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88975       };
88976     } catch (Dali::DaliException e) {
88977       {
88978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88979       };
88980     } catch (...) {
88981       {
88982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88983       };
88984     }
88985   }
88986
88987 }
88988
88989
88990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
88991   void * jresult ;
88992   Dali::Toolkit::VisualFactory result;
88993
88994   {
88995     try {
88996       result = Dali::Toolkit::VisualFactory::Get();
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 (Dali::DaliException e) {
89006       {
89007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89008       };
89009     } catch (...) {
89010       {
89011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89012       };
89013     }
89014   }
89015
89016   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
89017   return jresult;
89018 }
89019
89020
89021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
89022   void * jresult ;
89023   Dali::Toolkit::VisualFactory *result = 0 ;
89024
89025   {
89026     try {
89027       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
89028     } catch (std::out_of_range& e) {
89029       {
89030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89031       };
89032     } catch (std::exception& e) {
89033       {
89034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89035       };
89036     } catch (Dali::DaliException e) {
89037       {
89038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89039       };
89040     } catch (...) {
89041       {
89042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89043       };
89044     }
89045   }
89046
89047   jresult = (void *)result;
89048   return jresult;
89049 }
89050
89051
89052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
89053   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
89054
89055   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
89056   {
89057     try {
89058       delete arg1;
89059     } catch (std::out_of_range& e) {
89060       {
89061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89062       };
89063     } catch (std::exception& e) {
89064       {
89065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89066       };
89067     } catch (Dali::DaliException e) {
89068       {
89069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89070       };
89071     } catch (...) {
89072       {
89073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89074       };
89075     }
89076   }
89077
89078 }
89079
89080
89081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
89082   void * jresult ;
89083   Dali::Toolkit::VisualFactory *arg1 = 0 ;
89084   Dali::Toolkit::VisualFactory *result = 0 ;
89085
89086   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
89087   if (!arg1) {
89088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
89089     return 0;
89090   }
89091   {
89092     try {
89093       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
89094     } catch (std::out_of_range& e) {
89095       {
89096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89097       };
89098     } catch (std::exception& e) {
89099       {
89100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89101       };
89102     } catch (Dali::DaliException e) {
89103       {
89104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89105       };
89106     } catch (...) {
89107       {
89108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89109       };
89110     }
89111   }
89112
89113   jresult = (void *)result;
89114   return jresult;
89115 }
89116
89117
89118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
89119   void * jresult ;
89120   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
89121   Dali::Toolkit::VisualFactory *arg2 = 0 ;
89122   Dali::Toolkit::VisualFactory *result = 0 ;
89123
89124   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
89125   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
89126   if (!arg2) {
89127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
89128     return 0;
89129   }
89130   {
89131     try {
89132       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
89133     } catch (std::out_of_range& e) {
89134       {
89135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89136       };
89137     } catch (std::exception& e) {
89138       {
89139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89140       };
89141     } catch (Dali::DaliException e) {
89142       {
89143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89144       };
89145     } catch (...) {
89146       {
89147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89148       };
89149     }
89150   }
89151
89152   jresult = (void *)result;
89153   return jresult;
89154 }
89155
89156
89157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
89158   void * jresult ;
89159   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
89160   Dali::Property::Map *arg2 = 0 ;
89161   Dali::Toolkit::Visual::Base result;
89162
89163   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
89164   arg2 = (Dali::Property::Map *)jarg2;
89165   if (!arg2) {
89166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
89167     return 0;
89168   }
89169   {
89170     try {
89171       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
89172     } catch (std::out_of_range& e) {
89173       {
89174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89175       };
89176     } catch (std::exception& e) {
89177       {
89178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89179       };
89180     } catch (Dali::DaliException e) {
89181       {
89182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89183       };
89184     } catch (...) {
89185       {
89186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89187       };
89188     }
89189   }
89190
89191   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
89192   return jresult;
89193 }
89194
89195
89196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_1(void * jarg1, void * jarg2) {
89197   void * jresult ;
89198   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
89199   Dali::Image *arg2 = 0 ;
89200   Dali::Toolkit::Visual::Base result;
89201
89202   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
89203   arg2 = (Dali::Image *)jarg2;
89204   if (!arg2) {
89205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Image const & type is null", 0);
89206     return 0;
89207   }
89208   {
89209     try {
89210       result = (arg1)->CreateVisual((Dali::Image const &)*arg2);
89211     } catch (std::out_of_range& e) {
89212       {
89213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89214       };
89215     } catch (std::exception& e) {
89216       {
89217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89218       };
89219     } catch (Dali::DaliException e) {
89220       {
89221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89222       };
89223     } catch (...) {
89224       {
89225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89226       };
89227     }
89228   }
89229
89230   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
89231   return jresult;
89232 }
89233
89234
89235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
89236   void * jresult ;
89237   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
89238   std::string *arg2 = 0 ;
89239   Dali::ImageDimensions arg3 ;
89240   Dali::ImageDimensions *argp3 ;
89241   Dali::Toolkit::Visual::Base result;
89242
89243   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
89244   if (!jarg2) {
89245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89246     return 0;
89247   }
89248   std::string arg2_str(jarg2);
89249   arg2 = &arg2_str;
89250   argp3 = (Dali::ImageDimensions *)jarg3;
89251   if (!argp3) {
89252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
89253     return 0;
89254   }
89255   arg3 = *argp3;
89256   {
89257     try {
89258       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
89259     } catch (std::out_of_range& e) {
89260       {
89261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89262       };
89263     } catch (std::exception& e) {
89264       {
89265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89266       };
89267     } catch (Dali::DaliException e) {
89268       {
89269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89270       };
89271     } catch (...) {
89272       {
89273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89274       };
89275     }
89276   }
89277
89278   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
89279
89280   //argout typemap for const std::string&
89281
89282   return jresult;
89283 }
89284
89285
89286 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
89287   void * jresult ;
89288   Dali::Toolkit::AsyncImageLoader *result = 0 ;
89289
89290   {
89291     try {
89292       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
89293     } catch (std::out_of_range& e) {
89294       {
89295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89296       };
89297     } catch (std::exception& e) {
89298       {
89299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89300       };
89301     } catch (Dali::DaliException e) {
89302       {
89303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89304       };
89305     } catch (...) {
89306       {
89307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89308       };
89309     }
89310   }
89311
89312   jresult = (void *)result;
89313   return jresult;
89314 }
89315
89316
89317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
89318   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
89319
89320   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89321   {
89322     try {
89323       delete arg1;
89324     } catch (std::out_of_range& e) {
89325       {
89326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89327       };
89328     } catch (std::exception& e) {
89329       {
89330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89331       };
89332     } catch (Dali::DaliException e) {
89333       {
89334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89335       };
89336     } catch (...) {
89337       {
89338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89339       };
89340     }
89341   }
89342
89343 }
89344
89345
89346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
89347   void * jresult ;
89348   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
89349   Dali::Toolkit::AsyncImageLoader *result = 0 ;
89350
89351   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89352   if (!arg1) {
89353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
89354     return 0;
89355   }
89356   {
89357     try {
89358       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
89359     } catch (std::out_of_range& e) {
89360       {
89361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89362       };
89363     } catch (std::exception& e) {
89364       {
89365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89366       };
89367     } catch (Dali::DaliException e) {
89368       {
89369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89370       };
89371     } catch (...) {
89372       {
89373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89374       };
89375     }
89376   }
89377
89378   jresult = (void *)result;
89379   return jresult;
89380 }
89381
89382
89383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
89384   void * jresult ;
89385   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
89386   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
89387   Dali::Toolkit::AsyncImageLoader *result = 0 ;
89388
89389   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89390   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
89391   if (!arg2) {
89392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
89393     return 0;
89394   }
89395   {
89396     try {
89397       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
89398     } catch (std::out_of_range& e) {
89399       {
89400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89401       };
89402     } catch (std::exception& e) {
89403       {
89404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89405       };
89406     } catch (Dali::DaliException e) {
89407       {
89408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89409       };
89410     } catch (...) {
89411       {
89412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89413       };
89414     }
89415   }
89416
89417   jresult = (void *)result;
89418   return jresult;
89419 }
89420
89421
89422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
89423   void * jresult ;
89424   Dali::Toolkit::AsyncImageLoader result;
89425
89426   {
89427     try {
89428       result = Dali::Toolkit::AsyncImageLoader::New();
89429     } catch (std::out_of_range& e) {
89430       {
89431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89432       };
89433     } catch (std::exception& e) {
89434       {
89435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89436       };
89437     } catch (Dali::DaliException e) {
89438       {
89439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89440       };
89441     } catch (...) {
89442       {
89443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89444       };
89445     }
89446   }
89447
89448   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
89449   return jresult;
89450 }
89451
89452
89453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
89454   void * jresult ;
89455   Dali::BaseHandle arg1 ;
89456   Dali::BaseHandle *argp1 ;
89457   Dali::Toolkit::AsyncImageLoader result;
89458
89459   argp1 = (Dali::BaseHandle *)jarg1;
89460   if (!argp1) {
89461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
89462     return 0;
89463   }
89464   arg1 = *argp1;
89465   {
89466     try {
89467       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
89468     } catch (std::out_of_range& e) {
89469       {
89470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89471       };
89472     } catch (std::exception& e) {
89473       {
89474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89475       };
89476     } catch (Dali::DaliException e) {
89477       {
89478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89479       };
89480     } catch (...) {
89481       {
89482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89483       };
89484     }
89485   }
89486
89487   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
89488   return jresult;
89489 }
89490
89491
89492 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
89493   unsigned int jresult ;
89494   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
89495   std::string *arg2 = 0 ;
89496   uint32_t result;
89497
89498   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89499   if (!jarg2) {
89500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89501     return 0;
89502   }
89503   std::string arg2_str(jarg2);
89504   arg2 = &arg2_str;
89505   {
89506     try {
89507       result = (arg1)->Load((std::string const &)*arg2);
89508     } catch (std::out_of_range& e) {
89509       {
89510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89511       };
89512     } catch (std::exception& e) {
89513       {
89514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89515       };
89516     } catch (Dali::DaliException e) {
89517       {
89518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89519       };
89520     } catch (...) {
89521       {
89522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89523       };
89524     }
89525   }
89526
89527   jresult = result;
89528
89529   //argout typemap for const std::string&
89530
89531   return jresult;
89532 }
89533
89534
89535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
89536   unsigned int jresult ;
89537   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
89538   std::string *arg2 = 0 ;
89539   Dali::ImageDimensions arg3 ;
89540   Dali::ImageDimensions *argp3 ;
89541   uint32_t result;
89542
89543   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89544   if (!jarg2) {
89545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89546     return 0;
89547   }
89548   std::string arg2_str(jarg2);
89549   arg2 = &arg2_str;
89550   argp3 = (Dali::ImageDimensions *)jarg3;
89551   if (!argp3) {
89552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
89553     return 0;
89554   }
89555   arg3 = *argp3;
89556   {
89557     try {
89558       result = (arg1)->Load((std::string const &)*arg2,arg3);
89559     } catch (std::out_of_range& e) {
89560       {
89561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89562       };
89563     } catch (std::exception& e) {
89564       {
89565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89566       };
89567     } catch (Dali::DaliException e) {
89568       {
89569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89570       };
89571     } catch (...) {
89572       {
89573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89574       };
89575     }
89576   }
89577
89578   jresult = result;
89579
89580   //argout typemap for const std::string&
89581
89582   return jresult;
89583 }
89584
89585
89586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
89587   unsigned int jresult ;
89588   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
89589   std::string *arg2 = 0 ;
89590   Dali::ImageDimensions arg3 ;
89591   Dali::FittingMode::Type arg4 ;
89592   Dali::SamplingMode::Type arg5 ;
89593   bool arg6 ;
89594   Dali::ImageDimensions *argp3 ;
89595   uint32_t result;
89596
89597   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89598   if (!jarg2) {
89599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89600     return 0;
89601   }
89602   std::string arg2_str(jarg2);
89603   arg2 = &arg2_str;
89604   argp3 = (Dali::ImageDimensions *)jarg3;
89605   if (!argp3) {
89606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
89607     return 0;
89608   }
89609   arg3 = *argp3;
89610   arg4 = (Dali::FittingMode::Type)jarg4;
89611   arg5 = (Dali::SamplingMode::Type)jarg5;
89612   arg6 = jarg6 ? true : false;
89613   {
89614     try {
89615       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
89616     } catch (std::out_of_range& e) {
89617       {
89618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89619       };
89620     } catch (std::exception& e) {
89621       {
89622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89623       };
89624     } catch (Dali::DaliException e) {
89625       {
89626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89627       };
89628     } catch (...) {
89629       {
89630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89631       };
89632     }
89633   }
89634
89635   jresult = result;
89636
89637   //argout typemap for const std::string&
89638
89639   return jresult;
89640 }
89641
89642
89643 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
89644   unsigned int jresult ;
89645   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
89646   uint32_t arg2 ;
89647   bool result;
89648
89649   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89650   arg2 = (uint32_t)jarg2;
89651   {
89652     try {
89653       result = (bool)(arg1)->Cancel(arg2);
89654     } catch (std::out_of_range& e) {
89655       {
89656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89657       };
89658     } catch (std::exception& e) {
89659       {
89660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89661       };
89662     } catch (Dali::DaliException e) {
89663       {
89664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89665       };
89666     } catch (...) {
89667       {
89668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89669       };
89670     }
89671   }
89672
89673   jresult = result;
89674   return jresult;
89675 }
89676
89677
89678 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
89679   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
89680
89681   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89682   {
89683     try {
89684       (arg1)->CancelAll();
89685     } catch (std::out_of_range& e) {
89686       {
89687         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89688       };
89689     } catch (std::exception& e) {
89690       {
89691         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89692       };
89693     } catch (Dali::DaliException e) {
89694       {
89695         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89696       };
89697     } catch (...) {
89698       {
89699         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89700       };
89701     }
89702   }
89703
89704 }
89705
89706
89707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
89708   void * jresult ;
89709   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
89710   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
89711
89712   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
89713   {
89714     try {
89715       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
89716     } catch (std::out_of_range& e) {
89717       {
89718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89719       };
89720     } catch (std::exception& e) {
89721       {
89722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89723       };
89724     } catch (Dali::DaliException e) {
89725       {
89726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89727       };
89728     } catch (...) {
89729       {
89730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89731       };
89732     }
89733   }
89734
89735   jresult = (void *)result;
89736   return jresult;
89737 }
89738
89739
89740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
89741   void * jresult ;
89742   std::string *arg1 = 0 ;
89743   Dali::PixelData result;
89744
89745   if (!jarg1) {
89746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89747     return 0;
89748   }
89749   std::string arg1_str(jarg1);
89750   arg1 = &arg1_str;
89751   {
89752     try {
89753       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
89754     } catch (std::out_of_range& e) {
89755       {
89756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89757       };
89758     } catch (std::exception& e) {
89759       {
89760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89761       };
89762     } catch (Dali::DaliException e) {
89763       {
89764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89765       };
89766     } catch (...) {
89767       {
89768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89769       };
89770     }
89771   }
89772
89773   jresult = new Dali::PixelData((const Dali::PixelData &)result);
89774
89775   //argout typemap for const std::string&
89776
89777   return jresult;
89778 }
89779
89780
89781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
89782   void * jresult ;
89783   std::string *arg1 = 0 ;
89784   Dali::ImageDimensions arg2 ;
89785   Dali::ImageDimensions *argp2 ;
89786   Dali::PixelData result;
89787
89788   if (!jarg1) {
89789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89790     return 0;
89791   }
89792   std::string arg1_str(jarg1);
89793   arg1 = &arg1_str;
89794   argp2 = (Dali::ImageDimensions *)jarg2;
89795   if (!argp2) {
89796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
89797     return 0;
89798   }
89799   arg2 = *argp2;
89800   {
89801     try {
89802       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
89803     } catch (std::out_of_range& e) {
89804       {
89805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89806       };
89807     } catch (std::exception& e) {
89808       {
89809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89810       };
89811     } catch (Dali::DaliException e) {
89812       {
89813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89814       };
89815     } catch (...) {
89816       {
89817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89818       };
89819     }
89820   }
89821
89822   jresult = new Dali::PixelData((const Dali::PixelData &)result);
89823
89824   //argout typemap for const std::string&
89825
89826   return jresult;
89827 }
89828
89829
89830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
89831   void * jresult ;
89832   std::string *arg1 = 0 ;
89833   Dali::ImageDimensions arg2 ;
89834   Dali::FittingMode::Type arg3 ;
89835   Dali::SamplingMode::Type arg4 ;
89836   bool arg5 ;
89837   Dali::ImageDimensions *argp2 ;
89838   Dali::PixelData result;
89839
89840   if (!jarg1) {
89841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
89842     return 0;
89843   }
89844   std::string arg1_str(jarg1);
89845   arg1 = &arg1_str;
89846   argp2 = (Dali::ImageDimensions *)jarg2;
89847   if (!argp2) {
89848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
89849     return 0;
89850   }
89851   arg2 = *argp2;
89852   arg3 = (Dali::FittingMode::Type)jarg3;
89853   arg4 = (Dali::SamplingMode::Type)jarg4;
89854   arg5 = jarg5 ? true : false;
89855   {
89856     try {
89857       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
89858     } catch (std::out_of_range& e) {
89859       {
89860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89861       };
89862     } catch (std::exception& e) {
89863       {
89864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89865       };
89866     } catch (Dali::DaliException e) {
89867       {
89868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89869       };
89870     } catch (...) {
89871       {
89872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89873       };
89874     }
89875   }
89876
89877   jresult = new Dali::PixelData((const Dali::PixelData &)result);
89878
89879   //argout typemap for const std::string&
89880
89881   return jresult;
89882 }
89883
89884
89885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
89886   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
89887
89888   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
89889   {
89890     try {
89891       delete arg1;
89892     } catch (std::out_of_range& e) {
89893       {
89894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89895       };
89896     } catch (std::exception& e) {
89897       {
89898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89899       };
89900     } catch (Dali::DaliException e) {
89901       {
89902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89903       };
89904     } catch (...) {
89905       {
89906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89907       };
89908     }
89909   }
89910
89911 }
89912
89913
89914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
89915   void * jresult ;
89916   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
89917   Dali::Actor arg2 ;
89918   Dali::Actor arg3 ;
89919   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
89920   Dali::Actor *argp2 ;
89921   Dali::Actor *argp3 ;
89922   Dali::Actor result;
89923
89924   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
89925   argp2 = (Dali::Actor *)jarg2;
89926   if (!argp2) {
89927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89928     return 0;
89929   }
89930   arg2 = *argp2;
89931   argp3 = (Dali::Actor *)jarg3;
89932   if (!argp3) {
89933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
89934     return 0;
89935   }
89936   arg3 = *argp3;
89937   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
89938   {
89939     try {
89940       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
89941     } catch (std::out_of_range& e) {
89942       {
89943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89944       };
89945     } catch (std::exception& e) {
89946       {
89947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89948       };
89949     } catch (Dali::DaliException e) {
89950       {
89951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89952       };
89953     } catch (...) {
89954       {
89955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89956       };
89957     }
89958   }
89959
89960   jresult = new Dali::Actor((const Dali::Actor &)result);
89961   return jresult;
89962 }
89963
89964
89965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
89966   void * jresult ;
89967   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
89968
89969   {
89970     try {
89971       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
89972     } catch (std::out_of_range& e) {
89973       {
89974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89975       };
89976     } catch (std::exception& e) {
89977       {
89978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89979       };
89980     } catch (Dali::DaliException e) {
89981       {
89982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89983       };
89984     } catch (...) {
89985       {
89986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89987       };
89988     }
89989   }
89990
89991   jresult = (void *)result;
89992   return jresult;
89993 }
89994
89995
89996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
89997   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
89998   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
89999   if (director) {
90000     director->swig_connect_director(callback0);
90001   }
90002 }
90003
90004
90005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
90006   KeyboardFocusManager arg1 ;
90007   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
90008   KeyboardFocusManager *argp1 ;
90009
90010   argp1 = (KeyboardFocusManager *)jarg1;
90011   if (!argp1) {
90012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
90013     return ;
90014   }
90015   arg1 = *argp1;
90016   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
90017   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
90018   {
90019     try {
90020       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
90021     } catch (std::out_of_range& e) {
90022       {
90023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90024       };
90025     } catch (std::exception& e) {
90026       {
90027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90028       };
90029     } catch (Dali::DaliException e) {
90030       {
90031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90032       };
90033     } catch (...) {
90034       {
90035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90036       };
90037     }
90038   }
90039
90040 }
90041
90042
90043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
90044   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90045
90046   arg1 = (std::vector< unsigned int > *)jarg1;
90047   {
90048     try {
90049       (arg1)->clear();
90050     } catch (std::out_of_range& e) {
90051       {
90052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90053       };
90054     } catch (std::exception& e) {
90055       {
90056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90057       };
90058     } catch (Dali::DaliException e) {
90059       {
90060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90061       };
90062     } catch (...) {
90063       {
90064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90065       };
90066     }
90067   }
90068
90069 }
90070
90071
90072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
90073   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90074   unsigned int *arg2 = 0 ;
90075   unsigned int temp2 ;
90076
90077   arg1 = (std::vector< unsigned int > *)jarg1;
90078   temp2 = (unsigned int)jarg2;
90079   arg2 = &temp2;
90080   {
90081     try {
90082       (arg1)->push_back((unsigned int const &)*arg2);
90083     } catch (std::out_of_range& e) {
90084       {
90085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90086       };
90087     } catch (std::exception& e) {
90088       {
90089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90090       };
90091     } catch (Dali::DaliException e) {
90092       {
90093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90094       };
90095     } catch (...) {
90096       {
90097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90098       };
90099     }
90100   }
90101
90102 }
90103
90104
90105 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
90106   unsigned long jresult ;
90107   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90108   std::vector< unsigned int >::size_type result;
90109
90110   arg1 = (std::vector< unsigned int > *)jarg1;
90111   {
90112     try {
90113       result = ((std::vector< unsigned int > const *)arg1)->size();
90114     } catch (std::out_of_range& e) {
90115       {
90116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90117       };
90118     } catch (std::exception& e) {
90119       {
90120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90121       };
90122     } catch (Dali::DaliException e) {
90123       {
90124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90125       };
90126     } catch (...) {
90127       {
90128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90129       };
90130     }
90131   }
90132
90133   jresult = (unsigned long)result;
90134   return jresult;
90135 }
90136
90137
90138 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
90139   unsigned long jresult ;
90140   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90141   std::vector< unsigned int >::size_type result;
90142
90143   arg1 = (std::vector< unsigned int > *)jarg1;
90144   {
90145     try {
90146       result = ((std::vector< unsigned int > const *)arg1)->capacity();
90147     } catch (std::out_of_range& e) {
90148       {
90149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90150       };
90151     } catch (std::exception& e) {
90152       {
90153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90154       };
90155     } catch (Dali::DaliException e) {
90156       {
90157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90158       };
90159     } catch (...) {
90160       {
90161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90162       };
90163     }
90164   }
90165
90166   jresult = (unsigned long)result;
90167   return jresult;
90168 }
90169
90170
90171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
90172   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90173   std::vector< unsigned int >::size_type arg2 ;
90174
90175   arg1 = (std::vector< unsigned int > *)jarg1;
90176   arg2 = (std::vector< unsigned int >::size_type)jarg2;
90177   {
90178     try {
90179       (arg1)->reserve(arg2);
90180     } catch (std::out_of_range& e) {
90181       {
90182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90183       };
90184     } catch (std::exception& e) {
90185       {
90186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90187       };
90188     } catch (Dali::DaliException e) {
90189       {
90190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90191       };
90192     } catch (...) {
90193       {
90194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90195       };
90196     }
90197   }
90198
90199 }
90200
90201
90202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
90203   void * jresult ;
90204   std::vector< unsigned int > *result = 0 ;
90205
90206   {
90207     try {
90208       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
90209     } catch (std::out_of_range& e) {
90210       {
90211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90212       };
90213     } catch (std::exception& e) {
90214       {
90215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90216       };
90217     } catch (Dali::DaliException e) {
90218       {
90219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90220       };
90221     } catch (...) {
90222       {
90223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90224       };
90225     }
90226   }
90227
90228   jresult = (void *)result;
90229   return jresult;
90230 }
90231
90232
90233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
90234   void * jresult ;
90235   std::vector< unsigned int > *arg1 = 0 ;
90236   std::vector< unsigned int > *result = 0 ;
90237
90238   arg1 = (std::vector< unsigned int > *)jarg1;
90239   if (!arg1) {
90240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
90241     return 0;
90242   }
90243   {
90244     try {
90245       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
90246     } catch (std::out_of_range& e) {
90247       {
90248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90249       };
90250     } catch (std::exception& e) {
90251       {
90252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90253       };
90254     } catch (Dali::DaliException e) {
90255       {
90256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90257       };
90258     } catch (...) {
90259       {
90260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90261       };
90262     }
90263   }
90264
90265   jresult = (void *)result;
90266   return jresult;
90267 }
90268
90269
90270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
90271   void * jresult ;
90272   int arg1 ;
90273   std::vector< unsigned int > *result = 0 ;
90274
90275   arg1 = (int)jarg1;
90276   {
90277     try {
90278       try {
90279         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
90280       }
90281       catch(std::out_of_range &_e) {
90282         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90283         return 0;
90284       }
90285
90286     } catch (std::out_of_range& e) {
90287       {
90288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90289       };
90290     } catch (std::exception& e) {
90291       {
90292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90293       };
90294     } catch (Dali::DaliException e) {
90295       {
90296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90297       };
90298     } catch (...) {
90299       {
90300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90301       };
90302     }
90303   }
90304
90305   jresult = (void *)result;
90306   return jresult;
90307 }
90308
90309
90310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
90311   unsigned int jresult ;
90312   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90313   int arg2 ;
90314   unsigned int result;
90315
90316   arg1 = (std::vector< unsigned int > *)jarg1;
90317   arg2 = (int)jarg2;
90318   {
90319     try {
90320       try {
90321         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
90322       }
90323       catch(std::out_of_range &_e) {
90324         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90325         return 0;
90326       }
90327
90328     } catch (std::out_of_range& e) {
90329       {
90330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90331       };
90332     } catch (std::exception& e) {
90333       {
90334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90335       };
90336     } catch (Dali::DaliException e) {
90337       {
90338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90339       };
90340     } catch (...) {
90341       {
90342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90343       };
90344     }
90345   }
90346
90347   jresult = result;
90348   return jresult;
90349 }
90350
90351
90352 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
90353   unsigned int jresult ;
90354   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90355   int arg2 ;
90356   unsigned int *result = 0 ;
90357
90358   arg1 = (std::vector< unsigned int > *)jarg1;
90359   arg2 = (int)jarg2;
90360   {
90361     try {
90362       try {
90363         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
90364       }
90365       catch(std::out_of_range &_e) {
90366         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90367         return 0;
90368       }
90369
90370     } catch (std::out_of_range& e) {
90371       {
90372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90373       };
90374     } catch (std::exception& e) {
90375       {
90376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90377       };
90378     } catch (Dali::DaliException e) {
90379       {
90380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90381       };
90382     } catch (...) {
90383       {
90384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90385       };
90386     }
90387   }
90388
90389   jresult = *result;
90390   return jresult;
90391 }
90392
90393
90394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
90395   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90396   int arg2 ;
90397   unsigned int *arg3 = 0 ;
90398   unsigned int temp3 ;
90399
90400   arg1 = (std::vector< unsigned int > *)jarg1;
90401   arg2 = (int)jarg2;
90402   temp3 = (unsigned int)jarg3;
90403   arg3 = &temp3;
90404   {
90405     try {
90406       try {
90407         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
90408       }
90409       catch(std::out_of_range &_e) {
90410         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90411         return ;
90412       }
90413
90414     } catch (std::out_of_range& e) {
90415       {
90416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90417       };
90418     } catch (std::exception& e) {
90419       {
90420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90421       };
90422     } catch (Dali::DaliException e) {
90423       {
90424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90425       };
90426     } catch (...) {
90427       {
90428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90429       };
90430     }
90431   }
90432
90433 }
90434
90435
90436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
90437   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90438   std::vector< unsigned int > *arg2 = 0 ;
90439
90440   arg1 = (std::vector< unsigned int > *)jarg1;
90441   arg2 = (std::vector< unsigned int > *)jarg2;
90442   if (!arg2) {
90443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
90444     return ;
90445   }
90446   {
90447     try {
90448       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
90449     } catch (std::out_of_range& e) {
90450       {
90451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90452       };
90453     } catch (std::exception& e) {
90454       {
90455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90456       };
90457     } catch (Dali::DaliException e) {
90458       {
90459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90460       };
90461     } catch (...) {
90462       {
90463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90464       };
90465     }
90466   }
90467
90468 }
90469
90470
90471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
90472   void * jresult ;
90473   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90474   int arg2 ;
90475   int arg3 ;
90476   std::vector< unsigned int > *result = 0 ;
90477
90478   arg1 = (std::vector< unsigned int > *)jarg1;
90479   arg2 = (int)jarg2;
90480   arg3 = (int)jarg3;
90481   {
90482     try {
90483       try {
90484         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
90485       }
90486       catch(std::out_of_range &_e) {
90487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90488         return 0;
90489       }
90490       catch(std::invalid_argument &_e) {
90491         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90492         return 0;
90493       }
90494
90495     } catch (std::out_of_range& e) {
90496       {
90497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90498       };
90499     } catch (std::exception& e) {
90500       {
90501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90502       };
90503     } catch (Dali::DaliException e) {
90504       {
90505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90506       };
90507     } catch (...) {
90508       {
90509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90510       };
90511     }
90512   }
90513
90514   jresult = (void *)result;
90515   return jresult;
90516 }
90517
90518
90519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
90520   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90521   int arg2 ;
90522   unsigned int *arg3 = 0 ;
90523   unsigned int temp3 ;
90524
90525   arg1 = (std::vector< unsigned int > *)jarg1;
90526   arg2 = (int)jarg2;
90527   temp3 = (unsigned int)jarg3;
90528   arg3 = &temp3;
90529   {
90530     try {
90531       try {
90532         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
90533       }
90534       catch(std::out_of_range &_e) {
90535         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90536         return ;
90537       }
90538
90539     } catch (std::out_of_range& e) {
90540       {
90541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90542       };
90543     } catch (std::exception& e) {
90544       {
90545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90546       };
90547     } catch (Dali::DaliException e) {
90548       {
90549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90550       };
90551     } catch (...) {
90552       {
90553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90554       };
90555     }
90556   }
90557
90558 }
90559
90560
90561 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
90562   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90563   int arg2 ;
90564   std::vector< unsigned int > *arg3 = 0 ;
90565
90566   arg1 = (std::vector< unsigned int > *)jarg1;
90567   arg2 = (int)jarg2;
90568   arg3 = (std::vector< unsigned int > *)jarg3;
90569   if (!arg3) {
90570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
90571     return ;
90572   }
90573   {
90574     try {
90575       try {
90576         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
90577       }
90578       catch(std::out_of_range &_e) {
90579         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90580         return ;
90581       }
90582
90583     } catch (std::out_of_range& e) {
90584       {
90585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90586       };
90587     } catch (std::exception& e) {
90588       {
90589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90590       };
90591     } catch (Dali::DaliException e) {
90592       {
90593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90594       };
90595     } catch (...) {
90596       {
90597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90598       };
90599     }
90600   }
90601
90602 }
90603
90604
90605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
90606   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90607   int arg2 ;
90608
90609   arg1 = (std::vector< unsigned int > *)jarg1;
90610   arg2 = (int)jarg2;
90611   {
90612     try {
90613       try {
90614         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
90615       }
90616       catch(std::out_of_range &_e) {
90617         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90618         return ;
90619       }
90620
90621     } catch (std::out_of_range& e) {
90622       {
90623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90624       };
90625     } catch (std::exception& e) {
90626       {
90627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90628       };
90629     } catch (Dali::DaliException e) {
90630       {
90631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90632       };
90633     } catch (...) {
90634       {
90635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90636       };
90637     }
90638   }
90639
90640 }
90641
90642
90643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
90644   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90645   int arg2 ;
90646   int arg3 ;
90647
90648   arg1 = (std::vector< unsigned int > *)jarg1;
90649   arg2 = (int)jarg2;
90650   arg3 = (int)jarg3;
90651   {
90652     try {
90653       try {
90654         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
90655       }
90656       catch(std::out_of_range &_e) {
90657         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90658         return ;
90659       }
90660       catch(std::invalid_argument &_e) {
90661         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90662         return ;
90663       }
90664
90665     } catch (std::out_of_range& e) {
90666       {
90667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90668       };
90669     } catch (std::exception& e) {
90670       {
90671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90672       };
90673     } catch (Dali::DaliException e) {
90674       {
90675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90676       };
90677     } catch (...) {
90678       {
90679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90680       };
90681     }
90682   }
90683
90684 }
90685
90686
90687 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
90688   void * jresult ;
90689   unsigned int *arg1 = 0 ;
90690   int arg2 ;
90691   unsigned int temp1 ;
90692   std::vector< unsigned int > *result = 0 ;
90693
90694   temp1 = (unsigned int)jarg1;
90695   arg1 = &temp1;
90696   arg2 = (int)jarg2;
90697   {
90698     try {
90699       try {
90700         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
90701       }
90702       catch(std::out_of_range &_e) {
90703         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90704         return 0;
90705       }
90706
90707     } catch (std::out_of_range& e) {
90708       {
90709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90710       };
90711     } catch (std::exception& e) {
90712       {
90713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90714       };
90715     } catch (Dali::DaliException e) {
90716       {
90717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90718       };
90719     } catch (...) {
90720       {
90721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90722       };
90723     }
90724   }
90725
90726   jresult = (void *)result;
90727   return jresult;
90728 }
90729
90730
90731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
90732   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90733
90734   arg1 = (std::vector< unsigned int > *)jarg1;
90735   {
90736     try {
90737       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
90738     } catch (std::out_of_range& e) {
90739       {
90740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90741       };
90742     } catch (std::exception& e) {
90743       {
90744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90745       };
90746     } catch (Dali::DaliException e) {
90747       {
90748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90749       };
90750     } catch (...) {
90751       {
90752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90753       };
90754     }
90755   }
90756
90757 }
90758
90759
90760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
90761   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90762   int arg2 ;
90763   int arg3 ;
90764
90765   arg1 = (std::vector< unsigned int > *)jarg1;
90766   arg2 = (int)jarg2;
90767   arg3 = (int)jarg3;
90768   {
90769     try {
90770       try {
90771         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
90772       }
90773       catch(std::out_of_range &_e) {
90774         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90775         return ;
90776       }
90777       catch(std::invalid_argument &_e) {
90778         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90779         return ;
90780       }
90781
90782     } catch (std::out_of_range& e) {
90783       {
90784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90785       };
90786     } catch (std::exception& e) {
90787       {
90788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90789       };
90790     } catch (Dali::DaliException e) {
90791       {
90792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90793       };
90794     } catch (...) {
90795       {
90796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90797       };
90798     }
90799   }
90800
90801 }
90802
90803
90804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
90805   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90806   int arg2 ;
90807   std::vector< unsigned int > *arg3 = 0 ;
90808
90809   arg1 = (std::vector< unsigned int > *)jarg1;
90810   arg2 = (int)jarg2;
90811   arg3 = (std::vector< unsigned int > *)jarg3;
90812   if (!arg3) {
90813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
90814     return ;
90815   }
90816   {
90817     try {
90818       try {
90819         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
90820       }
90821       catch(std::out_of_range &_e) {
90822         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90823         return ;
90824       }
90825
90826     } catch (std::out_of_range& e) {
90827       {
90828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90829       };
90830     } catch (std::exception& e) {
90831       {
90832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90833       };
90834     } catch (Dali::DaliException e) {
90835       {
90836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90837       };
90838     } catch (...) {
90839       {
90840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90841       };
90842     }
90843   }
90844
90845 }
90846
90847
90848 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
90849   unsigned int jresult ;
90850   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90851   unsigned int *arg2 = 0 ;
90852   unsigned int temp2 ;
90853   bool result;
90854
90855   arg1 = (std::vector< unsigned int > *)jarg1;
90856   temp2 = (unsigned int)jarg2;
90857   arg2 = &temp2;
90858   {
90859     try {
90860       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
90861     } catch (std::out_of_range& e) {
90862       {
90863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90864       };
90865     } catch (std::exception& e) {
90866       {
90867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90868       };
90869     } catch (Dali::DaliException e) {
90870       {
90871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90872       };
90873     } catch (...) {
90874       {
90875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90876       };
90877     }
90878   }
90879
90880   jresult = result;
90881   return jresult;
90882 }
90883
90884
90885 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
90886   int jresult ;
90887   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90888   unsigned int *arg2 = 0 ;
90889   unsigned int temp2 ;
90890   int result;
90891
90892   arg1 = (std::vector< unsigned int > *)jarg1;
90893   temp2 = (unsigned int)jarg2;
90894   arg2 = &temp2;
90895   {
90896     try {
90897       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
90898     } catch (std::out_of_range& e) {
90899       {
90900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90901       };
90902     } catch (std::exception& e) {
90903       {
90904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90905       };
90906     } catch (Dali::DaliException e) {
90907       {
90908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90909       };
90910     } catch (...) {
90911       {
90912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90913       };
90914     }
90915   }
90916
90917   jresult = result;
90918   return jresult;
90919 }
90920
90921
90922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
90923   int jresult ;
90924   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90925   unsigned int *arg2 = 0 ;
90926   unsigned int temp2 ;
90927   int result;
90928
90929   arg1 = (std::vector< unsigned int > *)jarg1;
90930   temp2 = (unsigned int)jarg2;
90931   arg2 = &temp2;
90932   {
90933     try {
90934       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
90935     } catch (std::out_of_range& e) {
90936       {
90937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90938       };
90939     } catch (std::exception& e) {
90940       {
90941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90942       };
90943     } catch (Dali::DaliException e) {
90944       {
90945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90946       };
90947     } catch (...) {
90948       {
90949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90950       };
90951     }
90952   }
90953
90954   jresult = result;
90955   return jresult;
90956 }
90957
90958
90959 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
90960   unsigned int jresult ;
90961   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90962   unsigned int *arg2 = 0 ;
90963   unsigned int temp2 ;
90964   bool result;
90965
90966   arg1 = (std::vector< unsigned int > *)jarg1;
90967   temp2 = (unsigned int)jarg2;
90968   arg2 = &temp2;
90969   {
90970     try {
90971       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
90972     } catch (std::out_of_range& e) {
90973       {
90974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90975       };
90976     } catch (std::exception& e) {
90977       {
90978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90979       };
90980     } catch (Dali::DaliException e) {
90981       {
90982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90983       };
90984     } catch (...) {
90985       {
90986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90987       };
90988     }
90989   }
90990
90991   jresult = result;
90992   return jresult;
90993 }
90994
90995
90996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
90997   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
90998
90999   arg1 = (std::vector< unsigned int > *)jarg1;
91000   {
91001     try {
91002       delete arg1;
91003     } catch (std::out_of_range& e) {
91004       {
91005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91006       };
91007     } catch (std::exception& e) {
91008       {
91009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91010       };
91011     } catch (Dali::DaliException e) {
91012       {
91013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91014       };
91015     } catch (...) {
91016       {
91017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91018       };
91019     }
91020   }
91021
91022 }
91023
91024
91025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
91026   void * jresult ;
91027   std::pair< unsigned int,Dali::Actor > *result = 0 ;
91028
91029   {
91030     try {
91031       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
91032     } catch (std::out_of_range& e) {
91033       {
91034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91035       };
91036     } catch (std::exception& e) {
91037       {
91038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91039       };
91040     } catch (Dali::DaliException e) {
91041       {
91042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91043       };
91044     } catch (...) {
91045       {
91046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91047       };
91048     }
91049   }
91050
91051   jresult = (void *)result;
91052   return jresult;
91053 }
91054
91055
91056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
91057   void * jresult ;
91058   unsigned int arg1 ;
91059   Dali::Actor arg2 ;
91060   Dali::Actor *argp2 ;
91061   std::pair< unsigned int,Dali::Actor > *result = 0 ;
91062
91063   arg1 = (unsigned int)jarg1;
91064   argp2 = (Dali::Actor *)jarg2;
91065   if (!argp2) {
91066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91067     return 0;
91068   }
91069   arg2 = *argp2;
91070   {
91071     try {
91072       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
91073     } catch (std::out_of_range& e) {
91074       {
91075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91076       };
91077     } catch (std::exception& e) {
91078       {
91079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91080       };
91081     } catch (Dali::DaliException e) {
91082       {
91083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91084       };
91085     } catch (...) {
91086       {
91087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91088       };
91089     }
91090   }
91091
91092   jresult = (void *)result;
91093   return jresult;
91094 }
91095
91096
91097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
91098   void * jresult ;
91099   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
91100   std::pair< unsigned int,Dali::Actor > *result = 0 ;
91101
91102   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
91103   if (!arg1) {
91104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
91105     return 0;
91106   }
91107   {
91108     try {
91109       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
91110     } catch (std::out_of_range& e) {
91111       {
91112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91113       };
91114     } catch (std::exception& e) {
91115       {
91116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91117       };
91118     } catch (Dali::DaliException e) {
91119       {
91120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91121       };
91122     } catch (...) {
91123       {
91124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91125       };
91126     }
91127   }
91128
91129   jresult = (void *)result;
91130   return jresult;
91131 }
91132
91133
91134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
91135   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
91136   unsigned int arg2 ;
91137
91138   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
91139   arg2 = (unsigned int)jarg2;
91140   if (arg1) (arg1)->first = arg2;
91141 }
91142
91143
91144 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
91145   unsigned int jresult ;
91146   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
91147   unsigned int result;
91148
91149   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
91150   result = (unsigned int) ((arg1)->first);
91151   jresult = result;
91152   return jresult;
91153 }
91154
91155
91156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
91157   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
91158   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
91159
91160   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
91161   arg2 = (Dali::Actor *)jarg2;
91162   if (arg1) (arg1)->second = *arg2;
91163 }
91164
91165
91166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
91167   void * jresult ;
91168   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
91169   Dali::Actor *result = 0 ;
91170
91171   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
91172   result = (Dali::Actor *)& ((arg1)->second);
91173   jresult = (void *)result;
91174   return jresult;
91175 }
91176
91177
91178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
91179   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
91180
91181   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
91182   {
91183     try {
91184       delete arg1;
91185     } catch (std::out_of_range& e) {
91186       {
91187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91188       };
91189     } catch (std::exception& e) {
91190       {
91191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91192       };
91193     } catch (Dali::DaliException e) {
91194       {
91195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91196       };
91197     } catch (...) {
91198       {
91199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91200       };
91201     }
91202   }
91203
91204 }
91205
91206
91207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
91208   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91209
91210   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91211   {
91212     try {
91213       (arg1)->clear();
91214     } catch (std::out_of_range& e) {
91215       {
91216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91217       };
91218     } catch (std::exception& e) {
91219       {
91220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91221       };
91222     } catch (Dali::DaliException e) {
91223       {
91224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91225       };
91226     } catch (...) {
91227       {
91228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91229       };
91230     }
91231   }
91232
91233 }
91234
91235
91236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
91237   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91238   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
91239
91240   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91241   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
91242   if (!arg2) {
91243     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
91244     return ;
91245   }
91246   {
91247     try {
91248       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
91249     } catch (std::out_of_range& e) {
91250       {
91251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91252       };
91253     } catch (std::exception& e) {
91254       {
91255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91256       };
91257     } catch (Dali::DaliException e) {
91258       {
91259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91260       };
91261     } catch (...) {
91262       {
91263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91264       };
91265     }
91266   }
91267
91268 }
91269
91270
91271 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
91272   unsigned long jresult ;
91273   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91274   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
91275
91276   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91277   {
91278     try {
91279       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
91280     } catch (std::out_of_range& e) {
91281       {
91282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91283       };
91284     } catch (std::exception& e) {
91285       {
91286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91287       };
91288     } catch (Dali::DaliException e) {
91289       {
91290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91291       };
91292     } catch (...) {
91293       {
91294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91295       };
91296     }
91297   }
91298
91299   jresult = (unsigned long)result;
91300   return jresult;
91301 }
91302
91303
91304 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
91305   unsigned long jresult ;
91306   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91307   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
91308
91309   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91310   {
91311     try {
91312       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
91313     } catch (std::out_of_range& e) {
91314       {
91315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91316       };
91317     } catch (std::exception& e) {
91318       {
91319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91320       };
91321     } catch (Dali::DaliException e) {
91322       {
91323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91324       };
91325     } catch (...) {
91326       {
91327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91328       };
91329     }
91330   }
91331
91332   jresult = (unsigned long)result;
91333   return jresult;
91334 }
91335
91336
91337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
91338   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91339   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
91340
91341   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91342   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
91343   {
91344     try {
91345       (arg1)->reserve(arg2);
91346     } catch (std::out_of_range& e) {
91347       {
91348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91349       };
91350     } catch (std::exception& e) {
91351       {
91352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91353       };
91354     } catch (Dali::DaliException e) {
91355       {
91356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91357       };
91358     } catch (...) {
91359       {
91360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91361       };
91362     }
91363   }
91364
91365 }
91366
91367
91368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
91369   void * jresult ;
91370   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
91371
91372   {
91373     try {
91374       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
91375     } catch (std::out_of_range& e) {
91376       {
91377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91378       };
91379     } catch (std::exception& e) {
91380       {
91381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91382       };
91383     } catch (Dali::DaliException e) {
91384       {
91385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91386       };
91387     } catch (...) {
91388       {
91389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91390       };
91391     }
91392   }
91393
91394   jresult = (void *)result;
91395   return jresult;
91396 }
91397
91398
91399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
91400   void * jresult ;
91401   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
91402   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
91403
91404   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91405   if (!arg1) {
91406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
91407     return 0;
91408   }
91409   {
91410     try {
91411       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);
91412     } catch (std::out_of_range& e) {
91413       {
91414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91415       };
91416     } catch (std::exception& e) {
91417       {
91418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91419       };
91420     } catch (Dali::DaliException e) {
91421       {
91422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91423       };
91424     } catch (...) {
91425       {
91426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91427       };
91428     }
91429   }
91430
91431   jresult = (void *)result;
91432   return jresult;
91433 }
91434
91435
91436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
91437   void * jresult ;
91438   int arg1 ;
91439   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
91440
91441   arg1 = (int)jarg1;
91442   {
91443     try {
91444       try {
91445         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);
91446       }
91447       catch(std::out_of_range &_e) {
91448         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91449         return 0;
91450       }
91451
91452     } catch (std::out_of_range& e) {
91453       {
91454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91455       };
91456     } catch (std::exception& e) {
91457       {
91458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91459       };
91460     } catch (Dali::DaliException e) {
91461       {
91462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91463       };
91464     } catch (...) {
91465       {
91466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91467       };
91468     }
91469   }
91470
91471   jresult = (void *)result;
91472   return jresult;
91473 }
91474
91475
91476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
91477   void * jresult ;
91478   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91479   int arg2 ;
91480   std::pair< unsigned int,Dali::Actor > result;
91481
91482   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91483   arg2 = (int)jarg2;
91484   {
91485     try {
91486       try {
91487         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
91488       }
91489       catch(std::out_of_range &_e) {
91490         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91491         return 0;
91492       }
91493
91494     } catch (std::out_of_range& e) {
91495       {
91496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91497       };
91498     } catch (std::exception& e) {
91499       {
91500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91501       };
91502     } catch (Dali::DaliException e) {
91503       {
91504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91505       };
91506     } catch (...) {
91507       {
91508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91509       };
91510     }
91511   }
91512
91513   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
91514   return jresult;
91515 }
91516
91517
91518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
91519   void * jresult ;
91520   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91521   int arg2 ;
91522   std::pair< unsigned int,Dali::Actor > *result = 0 ;
91523
91524   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91525   arg2 = (int)jarg2;
91526   {
91527     try {
91528       try {
91529         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
91530       }
91531       catch(std::out_of_range &_e) {
91532         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91533         return 0;
91534       }
91535
91536     } catch (std::out_of_range& e) {
91537       {
91538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91539       };
91540     } catch (std::exception& e) {
91541       {
91542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91543       };
91544     } catch (Dali::DaliException e) {
91545       {
91546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91547       };
91548     } catch (...) {
91549       {
91550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91551       };
91552     }
91553   }
91554
91555   jresult = (void *)result;
91556   return jresult;
91557 }
91558
91559
91560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
91561   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91562   int arg2 ;
91563   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
91564
91565   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91566   arg2 = (int)jarg2;
91567   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
91568   if (!arg3) {
91569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
91570     return ;
91571   }
91572   {
91573     try {
91574       try {
91575         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);
91576       }
91577       catch(std::out_of_range &_e) {
91578         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91579         return ;
91580       }
91581
91582     } catch (std::out_of_range& e) {
91583       {
91584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91585       };
91586     } catch (std::exception& e) {
91587       {
91588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91589       };
91590     } catch (Dali::DaliException e) {
91591       {
91592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91593       };
91594     } catch (...) {
91595       {
91596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91597       };
91598     }
91599   }
91600
91601 }
91602
91603
91604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
91605   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91606   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
91607
91608   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91609   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
91610   if (!arg2) {
91611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
91612     return ;
91613   }
91614   {
91615     try {
91616       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);
91617     } catch (std::out_of_range& e) {
91618       {
91619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91620       };
91621     } catch (std::exception& e) {
91622       {
91623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91624       };
91625     } catch (Dali::DaliException e) {
91626       {
91627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91628       };
91629     } catch (...) {
91630       {
91631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91632       };
91633     }
91634   }
91635
91636 }
91637
91638
91639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
91640   void * jresult ;
91641   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91642   int arg2 ;
91643   int arg3 ;
91644   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
91645
91646   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91647   arg2 = (int)jarg2;
91648   arg3 = (int)jarg3;
91649   {
91650     try {
91651       try {
91652         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);
91653       }
91654       catch(std::out_of_range &_e) {
91655         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91656         return 0;
91657       }
91658       catch(std::invalid_argument &_e) {
91659         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91660         return 0;
91661       }
91662
91663     } catch (std::out_of_range& e) {
91664       {
91665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91666       };
91667     } catch (std::exception& e) {
91668       {
91669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91670       };
91671     } catch (Dali::DaliException e) {
91672       {
91673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91674       };
91675     } catch (...) {
91676       {
91677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91678       };
91679     }
91680   }
91681
91682   jresult = (void *)result;
91683   return jresult;
91684 }
91685
91686
91687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
91688   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91689   int arg2 ;
91690   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
91691
91692   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91693   arg2 = (int)jarg2;
91694   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
91695   if (!arg3) {
91696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
91697     return ;
91698   }
91699   {
91700     try {
91701       try {
91702         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);
91703       }
91704       catch(std::out_of_range &_e) {
91705         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91706         return ;
91707       }
91708
91709     } catch (std::out_of_range& e) {
91710       {
91711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91712       };
91713     } catch (std::exception& e) {
91714       {
91715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91716       };
91717     } catch (Dali::DaliException e) {
91718       {
91719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91720       };
91721     } catch (...) {
91722       {
91723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91724       };
91725     }
91726   }
91727
91728 }
91729
91730
91731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
91732   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91733   int arg2 ;
91734   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
91735
91736   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91737   arg2 = (int)jarg2;
91738   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
91739   if (!arg3) {
91740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
91741     return ;
91742   }
91743   {
91744     try {
91745       try {
91746         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);
91747       }
91748       catch(std::out_of_range &_e) {
91749         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91750         return ;
91751       }
91752
91753     } catch (std::out_of_range& e) {
91754       {
91755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91756       };
91757     } catch (std::exception& e) {
91758       {
91759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91760       };
91761     } catch (Dali::DaliException e) {
91762       {
91763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91764       };
91765     } catch (...) {
91766       {
91767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91768       };
91769     }
91770   }
91771
91772 }
91773
91774
91775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
91776   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91777   int arg2 ;
91778
91779   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91780   arg2 = (int)jarg2;
91781   {
91782     try {
91783       try {
91784         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
91785       }
91786       catch(std::out_of_range &_e) {
91787         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91788         return ;
91789       }
91790
91791     } catch (std::out_of_range& e) {
91792       {
91793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91794       };
91795     } catch (std::exception& e) {
91796       {
91797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91798       };
91799     } catch (Dali::DaliException e) {
91800       {
91801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91802       };
91803     } catch (...) {
91804       {
91805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91806       };
91807     }
91808   }
91809
91810 }
91811
91812
91813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
91814   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91815   int arg2 ;
91816   int arg3 ;
91817
91818   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91819   arg2 = (int)jarg2;
91820   arg3 = (int)jarg3;
91821   {
91822     try {
91823       try {
91824         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
91825       }
91826       catch(std::out_of_range &_e) {
91827         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91828         return ;
91829       }
91830       catch(std::invalid_argument &_e) {
91831         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91832         return ;
91833       }
91834
91835     } catch (std::out_of_range& e) {
91836       {
91837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91838       };
91839     } catch (std::exception& e) {
91840       {
91841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91842       };
91843     } catch (Dali::DaliException e) {
91844       {
91845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91846       };
91847     } catch (...) {
91848       {
91849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91850       };
91851     }
91852   }
91853
91854 }
91855
91856
91857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
91858   void * jresult ;
91859   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
91860   int arg2 ;
91861   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
91862
91863   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
91864   if (!arg1) {
91865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
91866     return 0;
91867   }
91868   arg2 = (int)jarg2;
91869   {
91870     try {
91871       try {
91872         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);
91873       }
91874       catch(std::out_of_range &_e) {
91875         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91876         return 0;
91877       }
91878
91879     } catch (std::out_of_range& e) {
91880       {
91881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91882       };
91883     } catch (std::exception& e) {
91884       {
91885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91886       };
91887     } catch (Dali::DaliException e) {
91888       {
91889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91890       };
91891     } catch (...) {
91892       {
91893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91894       };
91895     }
91896   }
91897
91898   jresult = (void *)result;
91899   return jresult;
91900 }
91901
91902
91903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
91904   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91905
91906   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91907   {
91908     try {
91909       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
91910     } catch (std::out_of_range& e) {
91911       {
91912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91913       };
91914     } catch (std::exception& e) {
91915       {
91916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91917       };
91918     } catch (Dali::DaliException e) {
91919       {
91920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91921       };
91922     } catch (...) {
91923       {
91924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91925       };
91926     }
91927   }
91928
91929 }
91930
91931
91932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
91933   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91934   int arg2 ;
91935   int arg3 ;
91936
91937   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91938   arg2 = (int)jarg2;
91939   arg3 = (int)jarg3;
91940   {
91941     try {
91942       try {
91943         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
91944       }
91945       catch(std::out_of_range &_e) {
91946         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91947         return ;
91948       }
91949       catch(std::invalid_argument &_e) {
91950         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
91951         return ;
91952       }
91953
91954     } catch (std::out_of_range& e) {
91955       {
91956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91957       };
91958     } catch (std::exception& e) {
91959       {
91960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91961       };
91962     } catch (Dali::DaliException e) {
91963       {
91964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91965       };
91966     } catch (...) {
91967       {
91968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91969       };
91970     }
91971   }
91972
91973 }
91974
91975
91976 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
91977   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
91978   int arg2 ;
91979   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
91980
91981   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
91982   arg2 = (int)jarg2;
91983   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
91984   if (!arg3) {
91985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
91986     return ;
91987   }
91988   {
91989     try {
91990       try {
91991         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);
91992       }
91993       catch(std::out_of_range &_e) {
91994         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
91995         return ;
91996       }
91997
91998     } catch (std::out_of_range& e) {
91999       {
92000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92001       };
92002     } catch (std::exception& e) {
92003       {
92004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92005       };
92006     } catch (Dali::DaliException e) {
92007       {
92008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92009       };
92010     } catch (...) {
92011       {
92012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92013       };
92014     }
92015   }
92016
92017 }
92018
92019
92020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
92021   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
92022
92023   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
92024   {
92025     try {
92026       delete arg1;
92027     } catch (std::out_of_range& e) {
92028       {
92029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92030       };
92031     } catch (std::exception& e) {
92032       {
92033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92034       };
92035     } catch (Dali::DaliException e) {
92036       {
92037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92038       };
92039     } catch (...) {
92040       {
92041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92042       };
92043     }
92044   }
92045
92046 }
92047
92048
92049 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
92050   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92051
92052   arg1 = (std::vector< Dali::Actor > *)jarg1;
92053   {
92054     try {
92055       (arg1)->clear();
92056     } catch (std::out_of_range& e) {
92057       {
92058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92059       };
92060     } catch (std::exception& e) {
92061       {
92062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92063       };
92064     } catch (Dali::DaliException e) {
92065       {
92066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92067       };
92068     } catch (...) {
92069       {
92070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92071       };
92072     }
92073   }
92074
92075 }
92076
92077
92078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
92079   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92080   Dali::Actor *arg2 = 0 ;
92081
92082   arg1 = (std::vector< Dali::Actor > *)jarg1;
92083   arg2 = (Dali::Actor *)jarg2;
92084   if (!arg2) {
92085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
92086     return ;
92087   }
92088   {
92089     try {
92090       (arg1)->push_back((Dali::Actor const &)*arg2);
92091     } catch (std::out_of_range& e) {
92092       {
92093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92094       };
92095     } catch (std::exception& e) {
92096       {
92097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92098       };
92099     } catch (Dali::DaliException e) {
92100       {
92101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92102       };
92103     } catch (...) {
92104       {
92105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92106       };
92107     }
92108   }
92109
92110 }
92111
92112
92113 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
92114   unsigned long jresult ;
92115   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92116   std::vector< Dali::Actor >::size_type result;
92117
92118   arg1 = (std::vector< Dali::Actor > *)jarg1;
92119   {
92120     try {
92121       result = ((std::vector< Dali::Actor > const *)arg1)->size();
92122     } catch (std::out_of_range& e) {
92123       {
92124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92125       };
92126     } catch (std::exception& e) {
92127       {
92128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92129       };
92130     } catch (Dali::DaliException e) {
92131       {
92132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92133       };
92134     } catch (...) {
92135       {
92136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92137       };
92138     }
92139   }
92140
92141   jresult = (unsigned long)result;
92142   return jresult;
92143 }
92144
92145
92146 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
92147   unsigned long jresult ;
92148   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92149   std::vector< Dali::Actor >::size_type result;
92150
92151   arg1 = (std::vector< Dali::Actor > *)jarg1;
92152   {
92153     try {
92154       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
92155     } catch (std::out_of_range& e) {
92156       {
92157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92158       };
92159     } catch (std::exception& e) {
92160       {
92161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92162       };
92163     } catch (Dali::DaliException e) {
92164       {
92165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92166       };
92167     } catch (...) {
92168       {
92169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92170       };
92171     }
92172   }
92173
92174   jresult = (unsigned long)result;
92175   return jresult;
92176 }
92177
92178
92179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
92180   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92181   std::vector< Dali::Actor >::size_type arg2 ;
92182
92183   arg1 = (std::vector< Dali::Actor > *)jarg1;
92184   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
92185   {
92186     try {
92187       (arg1)->reserve(arg2);
92188     } catch (std::out_of_range& e) {
92189       {
92190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92191       };
92192     } catch (std::exception& e) {
92193       {
92194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92195       };
92196     } catch (Dali::DaliException e) {
92197       {
92198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92199       };
92200     } catch (...) {
92201       {
92202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92203       };
92204     }
92205   }
92206
92207 }
92208
92209
92210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
92211   void * jresult ;
92212   std::vector< Dali::Actor > *result = 0 ;
92213
92214   {
92215     try {
92216       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
92217     } catch (std::out_of_range& e) {
92218       {
92219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92220       };
92221     } catch (std::exception& e) {
92222       {
92223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92224       };
92225     } catch (Dali::DaliException e) {
92226       {
92227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92228       };
92229     } catch (...) {
92230       {
92231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92232       };
92233     }
92234   }
92235
92236   jresult = (void *)result;
92237   return jresult;
92238 }
92239
92240
92241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
92242   void * jresult ;
92243   std::vector< Dali::Actor > *arg1 = 0 ;
92244   std::vector< Dali::Actor > *result = 0 ;
92245
92246   arg1 = (std::vector< Dali::Actor > *)jarg1;
92247   if (!arg1) {
92248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
92249     return 0;
92250   }
92251   {
92252     try {
92253       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
92254     } catch (std::out_of_range& e) {
92255       {
92256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92257       };
92258     } catch (std::exception& e) {
92259       {
92260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92261       };
92262     } catch (Dali::DaliException e) {
92263       {
92264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92265       };
92266     } catch (...) {
92267       {
92268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92269       };
92270     }
92271   }
92272
92273   jresult = (void *)result;
92274   return jresult;
92275 }
92276
92277
92278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
92279   void * jresult ;
92280   int arg1 ;
92281   std::vector< Dali::Actor > *result = 0 ;
92282
92283   arg1 = (int)jarg1;
92284   {
92285     try {
92286       try {
92287         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
92288       }
92289       catch(std::out_of_range &_e) {
92290         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92291         return 0;
92292       }
92293
92294     } catch (std::out_of_range& e) {
92295       {
92296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92297       };
92298     } catch (std::exception& e) {
92299       {
92300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92301       };
92302     } catch (Dali::DaliException e) {
92303       {
92304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92305       };
92306     } catch (...) {
92307       {
92308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92309       };
92310     }
92311   }
92312
92313   jresult = (void *)result;
92314   return jresult;
92315 }
92316
92317
92318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
92319   void * jresult ;
92320   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92321   int arg2 ;
92322   Dali::Actor result;
92323
92324   arg1 = (std::vector< Dali::Actor > *)jarg1;
92325   arg2 = (int)jarg2;
92326   {
92327     try {
92328       try {
92329         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
92330       }
92331       catch(std::out_of_range &_e) {
92332         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92333         return 0;
92334       }
92335
92336     } catch (std::out_of_range& e) {
92337       {
92338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92339       };
92340     } catch (std::exception& e) {
92341       {
92342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92343       };
92344     } catch (Dali::DaliException e) {
92345       {
92346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92347       };
92348     } catch (...) {
92349       {
92350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92351       };
92352     }
92353   }
92354
92355   jresult = new Dali::Actor((const Dali::Actor &)result);
92356   return jresult;
92357 }
92358
92359
92360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
92361   void * jresult ;
92362   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92363   int arg2 ;
92364   Dali::Actor *result = 0 ;
92365
92366   arg1 = (std::vector< Dali::Actor > *)jarg1;
92367   arg2 = (int)jarg2;
92368   {
92369     try {
92370       try {
92371         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
92372       }
92373       catch(std::out_of_range &_e) {
92374         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92375         return 0;
92376       }
92377
92378     } catch (std::out_of_range& e) {
92379       {
92380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92381       };
92382     } catch (std::exception& e) {
92383       {
92384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92385       };
92386     } catch (Dali::DaliException e) {
92387       {
92388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92389       };
92390     } catch (...) {
92391       {
92392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92393       };
92394     }
92395   }
92396
92397   jresult = (void *)result;
92398   return jresult;
92399 }
92400
92401
92402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
92403   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92404   int arg2 ;
92405   Dali::Actor *arg3 = 0 ;
92406
92407   arg1 = (std::vector< Dali::Actor > *)jarg1;
92408   arg2 = (int)jarg2;
92409   arg3 = (Dali::Actor *)jarg3;
92410   if (!arg3) {
92411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
92412     return ;
92413   }
92414   {
92415     try {
92416       try {
92417         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
92418       }
92419       catch(std::out_of_range &_e) {
92420         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92421         return ;
92422       }
92423
92424     } catch (std::out_of_range& e) {
92425       {
92426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92427       };
92428     } catch (std::exception& e) {
92429       {
92430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92431       };
92432     } catch (Dali::DaliException e) {
92433       {
92434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92435       };
92436     } catch (...) {
92437       {
92438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92439       };
92440     }
92441   }
92442
92443 }
92444
92445
92446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
92447   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92448   std::vector< Dali::Actor > *arg2 = 0 ;
92449
92450   arg1 = (std::vector< Dali::Actor > *)jarg1;
92451   arg2 = (std::vector< Dali::Actor > *)jarg2;
92452   if (!arg2) {
92453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
92454     return ;
92455   }
92456   {
92457     try {
92458       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
92459     } catch (std::out_of_range& e) {
92460       {
92461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92462       };
92463     } catch (std::exception& e) {
92464       {
92465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92466       };
92467     } catch (Dali::DaliException e) {
92468       {
92469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92470       };
92471     } catch (...) {
92472       {
92473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92474       };
92475     }
92476   }
92477
92478 }
92479
92480
92481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
92482   void * jresult ;
92483   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92484   int arg2 ;
92485   int arg3 ;
92486   std::vector< Dali::Actor > *result = 0 ;
92487
92488   arg1 = (std::vector< Dali::Actor > *)jarg1;
92489   arg2 = (int)jarg2;
92490   arg3 = (int)jarg3;
92491   {
92492     try {
92493       try {
92494         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
92495       }
92496       catch(std::out_of_range &_e) {
92497         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92498         return 0;
92499       }
92500       catch(std::invalid_argument &_e) {
92501         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92502         return 0;
92503       }
92504
92505     } catch (std::out_of_range& e) {
92506       {
92507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92508       };
92509     } catch (std::exception& e) {
92510       {
92511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92512       };
92513     } catch (Dali::DaliException e) {
92514       {
92515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92516       };
92517     } catch (...) {
92518       {
92519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92520       };
92521     }
92522   }
92523
92524   jresult = (void *)result;
92525   return jresult;
92526 }
92527
92528
92529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
92530   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92531   int arg2 ;
92532   Dali::Actor *arg3 = 0 ;
92533
92534   arg1 = (std::vector< Dali::Actor > *)jarg1;
92535   arg2 = (int)jarg2;
92536   arg3 = (Dali::Actor *)jarg3;
92537   if (!arg3) {
92538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
92539     return ;
92540   }
92541   {
92542     try {
92543       try {
92544         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
92545       }
92546       catch(std::out_of_range &_e) {
92547         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92548         return ;
92549       }
92550
92551     } catch (std::out_of_range& e) {
92552       {
92553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92554       };
92555     } catch (std::exception& e) {
92556       {
92557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92558       };
92559     } catch (Dali::DaliException e) {
92560       {
92561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92562       };
92563     } catch (...) {
92564       {
92565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92566       };
92567     }
92568   }
92569
92570 }
92571
92572
92573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
92574   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92575   int arg2 ;
92576   std::vector< Dali::Actor > *arg3 = 0 ;
92577
92578   arg1 = (std::vector< Dali::Actor > *)jarg1;
92579   arg2 = (int)jarg2;
92580   arg3 = (std::vector< Dali::Actor > *)jarg3;
92581   if (!arg3) {
92582     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
92583     return ;
92584   }
92585   {
92586     try {
92587       try {
92588         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
92589       }
92590       catch(std::out_of_range &_e) {
92591         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92592         return ;
92593       }
92594
92595     } catch (std::out_of_range& e) {
92596       {
92597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92598       };
92599     } catch (std::exception& e) {
92600       {
92601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92602       };
92603     } catch (Dali::DaliException e) {
92604       {
92605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92606       };
92607     } catch (...) {
92608       {
92609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92610       };
92611     }
92612   }
92613
92614 }
92615
92616
92617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
92618   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92619   int arg2 ;
92620
92621   arg1 = (std::vector< Dali::Actor > *)jarg1;
92622   arg2 = (int)jarg2;
92623   {
92624     try {
92625       try {
92626         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
92627       }
92628       catch(std::out_of_range &_e) {
92629         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92630         return ;
92631       }
92632
92633     } catch (std::out_of_range& e) {
92634       {
92635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92636       };
92637     } catch (std::exception& e) {
92638       {
92639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92640       };
92641     } catch (Dali::DaliException e) {
92642       {
92643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92644       };
92645     } catch (...) {
92646       {
92647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92648       };
92649     }
92650   }
92651
92652 }
92653
92654
92655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
92656   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92657   int arg2 ;
92658   int arg3 ;
92659
92660   arg1 = (std::vector< Dali::Actor > *)jarg1;
92661   arg2 = (int)jarg2;
92662   arg3 = (int)jarg3;
92663   {
92664     try {
92665       try {
92666         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
92667       }
92668       catch(std::out_of_range &_e) {
92669         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92670         return ;
92671       }
92672       catch(std::invalid_argument &_e) {
92673         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92674         return ;
92675       }
92676
92677     } catch (std::out_of_range& e) {
92678       {
92679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92680       };
92681     } catch (std::exception& e) {
92682       {
92683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92684       };
92685     } catch (Dali::DaliException e) {
92686       {
92687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92688       };
92689     } catch (...) {
92690       {
92691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92692       };
92693     }
92694   }
92695
92696 }
92697
92698
92699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
92700   void * jresult ;
92701   Dali::Actor *arg1 = 0 ;
92702   int arg2 ;
92703   std::vector< Dali::Actor > *result = 0 ;
92704
92705   arg1 = (Dali::Actor *)jarg1;
92706   if (!arg1) {
92707     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
92708     return 0;
92709   }
92710   arg2 = (int)jarg2;
92711   {
92712     try {
92713       try {
92714         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
92715       }
92716       catch(std::out_of_range &_e) {
92717         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92718         return 0;
92719       }
92720
92721     } catch (std::out_of_range& e) {
92722       {
92723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92724       };
92725     } catch (std::exception& e) {
92726       {
92727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92728       };
92729     } catch (Dali::DaliException e) {
92730       {
92731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92732       };
92733     } catch (...) {
92734       {
92735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92736       };
92737     }
92738   }
92739
92740   jresult = (void *)result;
92741   return jresult;
92742 }
92743
92744
92745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
92746   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92747
92748   arg1 = (std::vector< Dali::Actor > *)jarg1;
92749   {
92750     try {
92751       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
92752     } catch (std::out_of_range& e) {
92753       {
92754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92755       };
92756     } catch (std::exception& e) {
92757       {
92758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92759       };
92760     } catch (Dali::DaliException e) {
92761       {
92762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92763       };
92764     } catch (...) {
92765       {
92766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92767       };
92768     }
92769   }
92770
92771 }
92772
92773
92774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
92775   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92776   int arg2 ;
92777   int arg3 ;
92778
92779   arg1 = (std::vector< Dali::Actor > *)jarg1;
92780   arg2 = (int)jarg2;
92781   arg3 = (int)jarg3;
92782   {
92783     try {
92784       try {
92785         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
92786       }
92787       catch(std::out_of_range &_e) {
92788         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92789         return ;
92790       }
92791       catch(std::invalid_argument &_e) {
92792         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
92793         return ;
92794       }
92795
92796     } catch (std::out_of_range& e) {
92797       {
92798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92799       };
92800     } catch (std::exception& e) {
92801       {
92802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92803       };
92804     } catch (Dali::DaliException e) {
92805       {
92806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92807       };
92808     } catch (...) {
92809       {
92810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92811       };
92812     }
92813   }
92814
92815 }
92816
92817
92818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
92819   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92820   int arg2 ;
92821   std::vector< Dali::Actor > *arg3 = 0 ;
92822
92823   arg1 = (std::vector< Dali::Actor > *)jarg1;
92824   arg2 = (int)jarg2;
92825   arg3 = (std::vector< Dali::Actor > *)jarg3;
92826   if (!arg3) {
92827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
92828     return ;
92829   }
92830   {
92831     try {
92832       try {
92833         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
92834       }
92835       catch(std::out_of_range &_e) {
92836         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
92837         return ;
92838       }
92839
92840     } catch (std::out_of_range& e) {
92841       {
92842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92843       };
92844     } catch (std::exception& e) {
92845       {
92846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92847       };
92848     } catch (Dali::DaliException e) {
92849       {
92850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92851       };
92852     } catch (...) {
92853       {
92854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92855       };
92856     }
92857   }
92858
92859 }
92860
92861
92862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
92863   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
92864
92865   arg1 = (std::vector< Dali::Actor > *)jarg1;
92866   {
92867     try {
92868       delete arg1;
92869     } catch (std::out_of_range& e) {
92870       {
92871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92872       };
92873     } catch (std::exception& e) {
92874       {
92875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92876       };
92877     } catch (Dali::DaliException e) {
92878       {
92879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92880       };
92881     } catch (...) {
92882       {
92883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92884       };
92885     }
92886   }
92887
92888 }
92889
92890
92891 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
92892   unsigned int jresult ;
92893   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
92894   bool result;
92895
92896   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
92897   {
92898     try {
92899       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
92900     } catch (std::out_of_range& e) {
92901       {
92902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92903       };
92904     } catch (std::exception& e) {
92905       {
92906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92907       };
92908     } catch (Dali::DaliException e) {
92909       {
92910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92911       };
92912     } catch (...) {
92913       {
92914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92915       };
92916     }
92917   }
92918
92919   jresult = result;
92920   return jresult;
92921 }
92922
92923
92924 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
92925   unsigned long jresult ;
92926   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
92927   std::size_t result;
92928
92929   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
92930   {
92931     try {
92932       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
92933     } catch (std::out_of_range& e) {
92934       {
92935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92936       };
92937     } catch (std::exception& e) {
92938       {
92939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92940       };
92941     } catch (Dali::DaliException e) {
92942       {
92943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92944       };
92945     } catch (...) {
92946       {
92947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92948       };
92949     }
92950   }
92951
92952   jresult = (unsigned long)result;
92953   return jresult;
92954 }
92955
92956
92957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
92958   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
92959   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
92960
92961   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
92962   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
92963   {
92964     try {
92965       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
92966     } catch (std::out_of_range& e) {
92967       {
92968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92969       };
92970     } catch (std::exception& e) {
92971       {
92972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92973       };
92974     } catch (Dali::DaliException e) {
92975       {
92976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92977       };
92978     } catch (...) {
92979       {
92980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92981       };
92982     }
92983   }
92984
92985 }
92986
92987
92988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
92989   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
92990   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
92991
92992   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
92993   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
92994   {
92995     try {
92996       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
92997     } catch (std::out_of_range& e) {
92998       {
92999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93000       };
93001     } catch (std::exception& e) {
93002       {
93003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93004       };
93005     } catch (Dali::DaliException e) {
93006       {
93007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93008       };
93009     } catch (...) {
93010       {
93011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93012       };
93013     }
93014   }
93015
93016 }
93017
93018
93019 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
93020   unsigned int jresult ;
93021   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
93022   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
93023   bool result;
93024
93025   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
93026   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
93027   if (!arg2) {
93028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
93029     return 0;
93030   }
93031   {
93032     try {
93033       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
93034     } catch (std::out_of_range& e) {
93035       {
93036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93037       };
93038     } catch (std::exception& e) {
93039       {
93040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93041       };
93042     } catch (Dali::DaliException e) {
93043       {
93044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93045       };
93046     } catch (...) {
93047       {
93048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93049       };
93050     }
93051   }
93052
93053   jresult = result;
93054   return jresult;
93055 }
93056
93057
93058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
93059   void * jresult ;
93060   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
93061
93062   {
93063     try {
93064       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
93065     } catch (std::out_of_range& e) {
93066       {
93067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93068       };
93069     } catch (std::exception& e) {
93070       {
93071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93072       };
93073     } catch (Dali::DaliException e) {
93074       {
93075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93076       };
93077     } catch (...) {
93078       {
93079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93080       };
93081     }
93082   }
93083
93084   jresult = (void *)result;
93085   return jresult;
93086 }
93087
93088
93089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
93090   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
93091
93092   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
93093   {
93094     try {
93095       delete arg1;
93096     } catch (std::out_of_range& e) {
93097       {
93098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93099       };
93100     } catch (std::exception& e) {
93101       {
93102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93103       };
93104     } catch (Dali::DaliException e) {
93105       {
93106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93107       };
93108     } catch (...) {
93109       {
93110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93111       };
93112     }
93113   }
93114
93115 }
93116
93117
93118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
93119   unsigned int jresult ;
93120   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
93121   bool result;
93122
93123   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
93124   {
93125     try {
93126       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);
93127     } catch (std::out_of_range& e) {
93128       {
93129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93130       };
93131     } catch (std::exception& e) {
93132       {
93133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93134       };
93135     } catch (Dali::DaliException e) {
93136       {
93137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93138       };
93139     } catch (...) {
93140       {
93141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93142       };
93143     }
93144   }
93145
93146   jresult = result;
93147   return jresult;
93148 }
93149
93150
93151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
93152   unsigned long jresult ;
93153   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
93154   std::size_t result;
93155
93156   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
93157   {
93158     try {
93159       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);
93160     } catch (std::out_of_range& e) {
93161       {
93162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93163       };
93164     } catch (std::exception& e) {
93165       {
93166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93167       };
93168     } catch (Dali::DaliException e) {
93169       {
93170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93171       };
93172     } catch (...) {
93173       {
93174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93175       };
93176     }
93177   }
93178
93179   jresult = (unsigned long)result;
93180   return jresult;
93181 }
93182
93183
93184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
93185   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
93186   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
93187
93188   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
93189   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
93190   {
93191     try {
93192       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
93193     } catch (std::out_of_range& e) {
93194       {
93195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93196       };
93197     } catch (std::exception& e) {
93198       {
93199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93200       };
93201     } catch (Dali::DaliException e) {
93202       {
93203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93204       };
93205     } catch (...) {
93206       {
93207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93208       };
93209     }
93210   }
93211
93212 }
93213
93214
93215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
93216   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
93217   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
93218
93219   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
93220   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
93221   {
93222     try {
93223       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
93224     } catch (std::out_of_range& e) {
93225       {
93226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93227       };
93228     } catch (std::exception& e) {
93229       {
93230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93231       };
93232     } catch (Dali::DaliException e) {
93233       {
93234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93235       };
93236     } catch (...) {
93237       {
93238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93239       };
93240     }
93241   }
93242
93243 }
93244
93245
93246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93247   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
93248   Dali::Actor arg2 ;
93249   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
93250   Dali::Actor *argp2 ;
93251
93252   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
93253   argp2 = (Dali::Actor *)jarg2;
93254   if (!argp2) {
93255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93256     return ;
93257   }
93258   arg2 = *argp2;
93259   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
93260   {
93261     try {
93262       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
93263     } catch (std::out_of_range& e) {
93264       {
93265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93266       };
93267     } catch (std::exception& e) {
93268       {
93269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93270       };
93271     } catch (Dali::DaliException e) {
93272       {
93273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93274       };
93275     } catch (...) {
93276       {
93277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93278       };
93279     }
93280   }
93281
93282 }
93283
93284
93285 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
93286   void * jresult ;
93287   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
93288
93289   {
93290     try {
93291       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
93292     } catch (std::out_of_range& e) {
93293       {
93294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93295       };
93296     } catch (std::exception& e) {
93297       {
93298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93299       };
93300     } catch (Dali::DaliException e) {
93301       {
93302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93303       };
93304     } catch (...) {
93305       {
93306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93307       };
93308     }
93309   }
93310
93311   jresult = (void *)result;
93312   return jresult;
93313 }
93314
93315
93316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
93317   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
93318
93319   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
93320   {
93321     try {
93322       delete arg1;
93323     } catch (std::out_of_range& e) {
93324       {
93325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93326       };
93327     } catch (std::exception& e) {
93328       {
93329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93330       };
93331     } catch (Dali::DaliException e) {
93332       {
93333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93334       };
93335     } catch (...) {
93336       {
93337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93338       };
93339     }
93340   }
93341
93342 }
93343
93344
93345 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
93346   unsigned int jresult ;
93347   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
93348   bool result;
93349
93350   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
93351   {
93352     try {
93353       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
93354     } catch (std::out_of_range& e) {
93355       {
93356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93357       };
93358     } catch (std::exception& e) {
93359       {
93360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93361       };
93362     } catch (Dali::DaliException e) {
93363       {
93364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93365       };
93366     } catch (...) {
93367       {
93368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93369       };
93370     }
93371   }
93372
93373   jresult = result;
93374   return jresult;
93375 }
93376
93377
93378 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
93379   unsigned long jresult ;
93380   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
93381   std::size_t result;
93382
93383   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
93384   {
93385     try {
93386       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
93387     } catch (std::out_of_range& e) {
93388       {
93389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93390       };
93391     } catch (std::exception& e) {
93392       {
93393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93394       };
93395     } catch (Dali::DaliException e) {
93396       {
93397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93398       };
93399     } catch (...) {
93400       {
93401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93402       };
93403     }
93404   }
93405
93406   jresult = (unsigned long)result;
93407   return jresult;
93408 }
93409
93410
93411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
93412   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
93413   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
93414
93415   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
93416   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
93417   {
93418     try {
93419       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
93420     } catch (std::out_of_range& e) {
93421       {
93422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93423       };
93424     } catch (std::exception& e) {
93425       {
93426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93427       };
93428     } catch (Dali::DaliException e) {
93429       {
93430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93431       };
93432     } catch (...) {
93433       {
93434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93435       };
93436     }
93437   }
93438
93439 }
93440
93441
93442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93443   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
93444   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
93445
93446   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
93447   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
93448   {
93449     try {
93450       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
93451     } catch (std::out_of_range& e) {
93452       {
93453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93454       };
93455     } catch (std::exception& e) {
93456       {
93457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93458       };
93459     } catch (Dali::DaliException e) {
93460       {
93461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93462       };
93463     } catch (...) {
93464       {
93465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93466       };
93467     }
93468   }
93469
93470 }
93471
93472
93473 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
93474   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
93475   Dali::Actor arg2 ;
93476   Dali::Actor arg3 ;
93477   Dali::Actor *argp2 ;
93478   Dali::Actor *argp3 ;
93479
93480   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
93481   argp2 = (Dali::Actor *)jarg2;
93482   if (!argp2) {
93483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93484     return ;
93485   }
93486   arg2 = *argp2;
93487   argp3 = (Dali::Actor *)jarg3;
93488   if (!argp3) {
93489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93490     return ;
93491   }
93492   arg3 = *argp3;
93493   {
93494     try {
93495       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
93496     } catch (std::out_of_range& e) {
93497       {
93498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93499       };
93500     } catch (std::exception& e) {
93501       {
93502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93503       };
93504     } catch (Dali::DaliException e) {
93505       {
93506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93507       };
93508     } catch (...) {
93509       {
93510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93511       };
93512     }
93513   }
93514
93515 }
93516
93517
93518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
93519   void * jresult ;
93520   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
93521
93522   {
93523     try {
93524       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
93525     } catch (std::out_of_range& e) {
93526       {
93527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93528       };
93529     } catch (std::exception& e) {
93530       {
93531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93532       };
93533     } catch (Dali::DaliException e) {
93534       {
93535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93536       };
93537     } catch (...) {
93538       {
93539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93540       };
93541     }
93542   }
93543
93544   jresult = (void *)result;
93545   return jresult;
93546 }
93547
93548
93549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
93550   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
93551
93552   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
93553   {
93554     try {
93555       delete arg1;
93556     } catch (std::out_of_range& e) {
93557       {
93558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93559       };
93560     } catch (std::exception& e) {
93561       {
93562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93563       };
93564     } catch (Dali::DaliException e) {
93565       {
93566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93567       };
93568     } catch (...) {
93569       {
93570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93571       };
93572     }
93573   }
93574
93575 }
93576
93577
93578 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
93579   unsigned int jresult ;
93580   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
93581   bool result;
93582
93583   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
93584   {
93585     try {
93586       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
93587     } catch (std::out_of_range& e) {
93588       {
93589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93590       };
93591     } catch (std::exception& e) {
93592       {
93593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93594       };
93595     } catch (Dali::DaliException e) {
93596       {
93597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93598       };
93599     } catch (...) {
93600       {
93601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93602       };
93603     }
93604   }
93605
93606   jresult = result;
93607   return jresult;
93608 }
93609
93610
93611 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
93612   unsigned long jresult ;
93613   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
93614   std::size_t result;
93615
93616   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
93617   {
93618     try {
93619       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
93620     } catch (std::out_of_range& e) {
93621       {
93622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93623       };
93624     } catch (std::exception& e) {
93625       {
93626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93627       };
93628     } catch (Dali::DaliException e) {
93629       {
93630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93631       };
93632     } catch (...) {
93633       {
93634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93635       };
93636     }
93637   }
93638
93639   jresult = (unsigned long)result;
93640   return jresult;
93641 }
93642
93643
93644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
93645   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
93646   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
93647
93648   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
93649   arg2 = (void (*)(Dali::Actor,bool))jarg2;
93650   {
93651     try {
93652       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
93653     } catch (std::out_of_range& e) {
93654       {
93655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93656       };
93657     } catch (std::exception& e) {
93658       {
93659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93660       };
93661     } catch (Dali::DaliException e) {
93662       {
93663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93664       };
93665     } catch (...) {
93666       {
93667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93668       };
93669     }
93670   }
93671
93672 }
93673
93674
93675 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93676   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
93677   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
93678
93679   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
93680   arg2 = (void (*)(Dali::Actor,bool))jarg2;
93681   {
93682     try {
93683       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
93684     } catch (std::out_of_range& e) {
93685       {
93686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93687       };
93688     } catch (std::exception& e) {
93689       {
93690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93691       };
93692     } catch (Dali::DaliException e) {
93693       {
93694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93695       };
93696     } catch (...) {
93697       {
93698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93699       };
93700     }
93701   }
93702
93703 }
93704
93705
93706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
93707   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
93708   Dali::Actor arg2 ;
93709   bool arg3 ;
93710   Dali::Actor *argp2 ;
93711
93712   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
93713   argp2 = (Dali::Actor *)jarg2;
93714   if (!argp2) {
93715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
93716     return ;
93717   }
93718   arg2 = *argp2;
93719   arg3 = jarg3 ? true : false;
93720   {
93721     try {
93722       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
93723     } catch (std::out_of_range& e) {
93724       {
93725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93726       };
93727     } catch (std::exception& e) {
93728       {
93729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93730       };
93731     } catch (Dali::DaliException e) {
93732       {
93733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93734       };
93735     } catch (...) {
93736       {
93737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93738       };
93739     }
93740   }
93741
93742 }
93743
93744
93745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
93746   void * jresult ;
93747   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
93748
93749   {
93750     try {
93751       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
93752     } catch (std::out_of_range& e) {
93753       {
93754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93755       };
93756     } catch (std::exception& e) {
93757       {
93758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93759       };
93760     } catch (Dali::DaliException e) {
93761       {
93762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93763       };
93764     } catch (...) {
93765       {
93766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93767       };
93768     }
93769   }
93770
93771   jresult = (void *)result;
93772   return jresult;
93773 }
93774
93775
93776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
93777   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
93778
93779   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
93780   {
93781     try {
93782       delete arg1;
93783     } catch (std::out_of_range& e) {
93784       {
93785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93786       };
93787     } catch (std::exception& e) {
93788       {
93789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93790       };
93791     } catch (Dali::DaliException e) {
93792       {
93793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93794       };
93795     } catch (...) {
93796       {
93797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93798       };
93799     }
93800   }
93801
93802 }
93803
93804
93805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
93806   unsigned int jresult ;
93807   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93808   bool result;
93809
93810   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93811   {
93812     try {
93813       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);
93814     } catch (std::out_of_range& e) {
93815       {
93816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93817       };
93818     } catch (std::exception& e) {
93819       {
93820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93821       };
93822     } catch (Dali::DaliException e) {
93823       {
93824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93825       };
93826     } catch (...) {
93827       {
93828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93829       };
93830     }
93831   }
93832
93833   jresult = result;
93834   return jresult;
93835 }
93836
93837
93838 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
93839   unsigned long jresult ;
93840   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93841   std::size_t result;
93842
93843   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93844   {
93845     try {
93846       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);
93847     } catch (std::out_of_range& e) {
93848       {
93849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93850       };
93851     } catch (std::exception& e) {
93852       {
93853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93854       };
93855     } catch (Dali::DaliException e) {
93856       {
93857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93858       };
93859     } catch (...) {
93860       {
93861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93862       };
93863     }
93864   }
93865
93866   jresult = (unsigned long)result;
93867   return jresult;
93868 }
93869
93870
93871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
93872   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93873   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
93874
93875   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93876   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
93877   {
93878     try {
93879       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
93880     } catch (std::out_of_range& e) {
93881       {
93882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93883       };
93884     } catch (std::exception& e) {
93885       {
93886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93887       };
93888     } catch (Dali::DaliException e) {
93889       {
93890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93891       };
93892     } catch (...) {
93893       {
93894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93895       };
93896     }
93897   }
93898
93899 }
93900
93901
93902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93903   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93904   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
93905
93906   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93907   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
93908   {
93909     try {
93910       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
93911     } catch (std::out_of_range& e) {
93912       {
93913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93914       };
93915     } catch (std::exception& e) {
93916       {
93917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93918       };
93919     } catch (Dali::DaliException e) {
93920       {
93921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93922       };
93923     } catch (...) {
93924       {
93925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93926       };
93927     }
93928   }
93929
93930 }
93931
93932
93933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93934   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
93935   Dali::Toolkit::StyleManager arg2 ;
93936   Dali::StyleChange::Type arg3 ;
93937   Dali::Toolkit::StyleManager *argp2 ;
93938
93939   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
93940   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
93941   if (!argp2) {
93942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
93943     return ;
93944   }
93945   arg2 = *argp2;
93946   arg3 = (Dali::StyleChange::Type)jarg3;
93947   {
93948     try {
93949       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
93950     } catch (std::out_of_range& e) {
93951       {
93952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93953       };
93954     } catch (std::exception& e) {
93955       {
93956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93957       };
93958     } catch (Dali::DaliException e) {
93959       {
93960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93961       };
93962     } catch (...) {
93963       {
93964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93965       };
93966     }
93967   }
93968
93969 }
93970
93971
93972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
93973   void * jresult ;
93974   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
93975
93976   {
93977     try {
93978       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
93979     } catch (std::out_of_range& e) {
93980       {
93981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93982       };
93983     } catch (std::exception& e) {
93984       {
93985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93986       };
93987     } catch (Dali::DaliException e) {
93988       {
93989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93990       };
93991     } catch (...) {
93992       {
93993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93994       };
93995     }
93996   }
93997
93998   jresult = (void *)result;
93999   return jresult;
94000 }
94001
94002
94003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
94004   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
94005
94006   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
94007   {
94008     try {
94009       delete arg1;
94010     } catch (std::out_of_range& e) {
94011       {
94012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94013       };
94014     } catch (std::exception& e) {
94015       {
94016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94017       };
94018     } catch (Dali::DaliException e) {
94019       {
94020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94021       };
94022     } catch (...) {
94023       {
94024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94025       };
94026     }
94027   }
94028
94029 }
94030
94031
94032 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
94033   unsigned int jresult ;
94034   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
94035   bool result;
94036
94037   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
94038   {
94039     try {
94040       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
94041     } catch (std::out_of_range& e) {
94042       {
94043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94044       };
94045     } catch (std::exception& e) {
94046       {
94047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94048       };
94049     } catch (Dali::DaliException e) {
94050       {
94051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94052       };
94053     } catch (...) {
94054       {
94055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94056       };
94057     }
94058   }
94059
94060   jresult = result;
94061   return jresult;
94062 }
94063
94064
94065 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
94066   unsigned long jresult ;
94067   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
94068   std::size_t result;
94069
94070   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
94071   {
94072     try {
94073       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
94074     } catch (std::out_of_range& e) {
94075       {
94076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94077       };
94078     } catch (std::exception& e) {
94079       {
94080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94081       };
94082     } catch (Dali::DaliException e) {
94083       {
94084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94085       };
94086     } catch (...) {
94087       {
94088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94089       };
94090     }
94091   }
94092
94093   jresult = (unsigned long)result;
94094   return jresult;
94095 }
94096
94097
94098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
94099   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
94100   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
94101
94102   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
94103   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
94104   {
94105     try {
94106       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
94107     } catch (std::out_of_range& e) {
94108       {
94109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94110       };
94111     } catch (std::exception& e) {
94112       {
94113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94114       };
94115     } catch (Dali::DaliException e) {
94116       {
94117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94118       };
94119     } catch (...) {
94120       {
94121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94122       };
94123     }
94124   }
94125
94126 }
94127
94128
94129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
94130   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
94131   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
94132
94133   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
94134   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
94135   {
94136     try {
94137       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
94138     } catch (std::out_of_range& e) {
94139       {
94140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94141       };
94142     } catch (std::exception& e) {
94143       {
94144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94145       };
94146     } catch (Dali::DaliException e) {
94147       {
94148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94149       };
94150     } catch (...) {
94151       {
94152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94153       };
94154     }
94155   }
94156
94157 }
94158
94159
94160 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
94161   unsigned int jresult ;
94162   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
94163   Dali::Toolkit::Button arg2 ;
94164   Dali::Toolkit::Button *argp2 ;
94165   bool result;
94166
94167   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
94168   argp2 = (Dali::Toolkit::Button *)jarg2;
94169   if (!argp2) {
94170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
94171     return 0;
94172   }
94173   arg2 = *argp2;
94174   {
94175     try {
94176       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
94177     } catch (std::out_of_range& e) {
94178       {
94179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94180       };
94181     } catch (std::exception& e) {
94182       {
94183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94184       };
94185     } catch (Dali::DaliException e) {
94186       {
94187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94188       };
94189     } catch (...) {
94190       {
94191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94192       };
94193     }
94194   }
94195
94196   jresult = result;
94197   return jresult;
94198 }
94199
94200
94201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
94202   void * jresult ;
94203   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
94204
94205   {
94206     try {
94207       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
94208     } catch (std::out_of_range& e) {
94209       {
94210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94211       };
94212     } catch (std::exception& e) {
94213       {
94214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94215       };
94216     } catch (Dali::DaliException e) {
94217       {
94218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94219       };
94220     } catch (...) {
94221       {
94222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94223       };
94224     }
94225   }
94226
94227   jresult = (void *)result;
94228   return jresult;
94229 }
94230
94231
94232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
94233   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
94234
94235   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
94236   {
94237     try {
94238       delete arg1;
94239     } catch (std::out_of_range& e) {
94240       {
94241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94242       };
94243     } catch (std::exception& e) {
94244       {
94245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94246       };
94247     } catch (Dali::DaliException e) {
94248       {
94249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94250       };
94251     } catch (...) {
94252       {
94253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94254       };
94255     }
94256   }
94257
94258 }
94259
94260
94261 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
94262   unsigned int jresult ;
94263   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
94264   bool result;
94265
94266   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
94267   {
94268     try {
94269       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
94270     } catch (std::out_of_range& e) {
94271       {
94272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94273       };
94274     } catch (std::exception& e) {
94275       {
94276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94277       };
94278     } catch (Dali::DaliException e) {
94279       {
94280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94281       };
94282     } catch (...) {
94283       {
94284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94285       };
94286     }
94287   }
94288
94289   jresult = result;
94290   return jresult;
94291 }
94292
94293
94294 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
94295   unsigned long jresult ;
94296   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
94297   std::size_t result;
94298
94299   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
94300   {
94301     try {
94302       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
94303     } catch (std::out_of_range& e) {
94304       {
94305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94306       };
94307     } catch (std::exception& e) {
94308       {
94309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94310       };
94311     } catch (Dali::DaliException e) {
94312       {
94313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94314       };
94315     } catch (...) {
94316       {
94317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94318       };
94319     }
94320   }
94321
94322   jresult = (unsigned long)result;
94323   return jresult;
94324 }
94325
94326
94327 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
94328   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
94329   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
94330
94331   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
94332   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
94333   {
94334     try {
94335       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
94336     } catch (std::out_of_range& e) {
94337       {
94338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94339       };
94340     } catch (std::exception& e) {
94341       {
94342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94343       };
94344     } catch (Dali::DaliException e) {
94345       {
94346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94347       };
94348     } catch (...) {
94349       {
94350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94351       };
94352     }
94353   }
94354
94355 }
94356
94357
94358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
94359   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
94360   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
94361
94362   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
94363   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
94364   {
94365     try {
94366       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
94367     } catch (std::out_of_range& e) {
94368       {
94369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94370       };
94371     } catch (std::exception& e) {
94372       {
94373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94374       };
94375     } catch (Dali::DaliException e) {
94376       {
94377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94378       };
94379     } catch (...) {
94380       {
94381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94382       };
94383     }
94384   }
94385
94386 }
94387
94388
94389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
94390   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
94391   Dali::Toolkit::GaussianBlurView arg2 ;
94392   Dali::Toolkit::GaussianBlurView *argp2 ;
94393
94394   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
94395   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
94396   if (!argp2) {
94397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
94398     return ;
94399   }
94400   arg2 = *argp2;
94401   {
94402     try {
94403       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
94404     } catch (std::out_of_range& e) {
94405       {
94406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94407       };
94408     } catch (std::exception& e) {
94409       {
94410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94411       };
94412     } catch (Dali::DaliException e) {
94413       {
94414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94415       };
94416     } catch (...) {
94417       {
94418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94419       };
94420     }
94421   }
94422
94423 }
94424
94425
94426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
94427   void * jresult ;
94428   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
94429
94430   {
94431     try {
94432       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
94433     } catch (std::out_of_range& e) {
94434       {
94435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94436       };
94437     } catch (std::exception& e) {
94438       {
94439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94440       };
94441     } catch (Dali::DaliException e) {
94442       {
94443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94444       };
94445     } catch (...) {
94446       {
94447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94448       };
94449     }
94450   }
94451
94452   jresult = (void *)result;
94453   return jresult;
94454 }
94455
94456
94457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
94458   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
94459
94460   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
94461   {
94462     try {
94463       delete arg1;
94464     } catch (std::out_of_range& e) {
94465       {
94466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94467       };
94468     } catch (std::exception& e) {
94469       {
94470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94471       };
94472     } catch (Dali::DaliException e) {
94473       {
94474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94475       };
94476     } catch (...) {
94477       {
94478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94479       };
94480     }
94481   }
94482
94483 }
94484
94485
94486 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
94487   unsigned int jresult ;
94488   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
94489   bool result;
94490
94491   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
94492   {
94493     try {
94494       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);
94495     } catch (std::out_of_range& e) {
94496       {
94497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94498       };
94499     } catch (std::exception& e) {
94500       {
94501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94502       };
94503     } catch (Dali::DaliException e) {
94504       {
94505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94506       };
94507     } catch (...) {
94508       {
94509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94510       };
94511     }
94512   }
94513
94514   jresult = result;
94515   return jresult;
94516 }
94517
94518
94519 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
94520   unsigned long jresult ;
94521   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
94522   std::size_t result;
94523
94524   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
94525   {
94526     try {
94527       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);
94528     } catch (std::out_of_range& e) {
94529       {
94530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94531       };
94532     } catch (std::exception& e) {
94533       {
94534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94535       };
94536     } catch (Dali::DaliException e) {
94537       {
94538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94539       };
94540     } catch (...) {
94541       {
94542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94543       };
94544     }
94545   }
94546
94547   jresult = (unsigned long)result;
94548   return jresult;
94549 }
94550
94551
94552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
94553   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
94554   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
94555
94556   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
94557   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
94558   {
94559     try {
94560       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
94561     } catch (std::out_of_range& e) {
94562       {
94563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94564       };
94565     } catch (std::exception& e) {
94566       {
94567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94568       };
94569     } catch (Dali::DaliException e) {
94570       {
94571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94572       };
94573     } catch (...) {
94574       {
94575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94576       };
94577     }
94578   }
94579
94580 }
94581
94582
94583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
94584   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
94585   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
94586
94587   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
94588   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
94589   {
94590     try {
94591       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
94592     } catch (std::out_of_range& e) {
94593       {
94594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94595       };
94596     } catch (std::exception& e) {
94597       {
94598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94599       };
94600     } catch (Dali::DaliException e) {
94601       {
94602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94603       };
94604     } catch (...) {
94605       {
94606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94607       };
94608     }
94609   }
94610
94611 }
94612
94613
94614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
94615   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
94616   Dali::Toolkit::PageTurnView arg2 ;
94617   unsigned int arg3 ;
94618   bool arg4 ;
94619   Dali::Toolkit::PageTurnView *argp2 ;
94620
94621   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
94622   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
94623   if (!argp2) {
94624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
94625     return ;
94626   }
94627   arg2 = *argp2;
94628   arg3 = (unsigned int)jarg3;
94629   arg4 = jarg4 ? true : false;
94630   {
94631     try {
94632       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
94633     } catch (std::out_of_range& e) {
94634       {
94635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94636       };
94637     } catch (std::exception& e) {
94638       {
94639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94640       };
94641     } catch (Dali::DaliException e) {
94642       {
94643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94644       };
94645     } catch (...) {
94646       {
94647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94648       };
94649     }
94650   }
94651
94652 }
94653
94654
94655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
94656   void * jresult ;
94657   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
94658
94659   {
94660     try {
94661       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
94662     } catch (std::out_of_range& e) {
94663       {
94664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94665       };
94666     } catch (std::exception& e) {
94667       {
94668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94669       };
94670     } catch (Dali::DaliException e) {
94671       {
94672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94673       };
94674     } catch (...) {
94675       {
94676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94677       };
94678     }
94679   }
94680
94681   jresult = (void *)result;
94682   return jresult;
94683 }
94684
94685
94686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
94687   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
94688
94689   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
94690   {
94691     try {
94692       delete arg1;
94693     } catch (std::out_of_range& e) {
94694       {
94695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94696       };
94697     } catch (std::exception& e) {
94698       {
94699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94700       };
94701     } catch (Dali::DaliException e) {
94702       {
94703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94704       };
94705     } catch (...) {
94706       {
94707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94708       };
94709     }
94710   }
94711
94712 }
94713
94714
94715 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
94716   unsigned int jresult ;
94717   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94718   bool result;
94719
94720   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94721   {
94722     try {
94723       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
94724     } catch (std::out_of_range& e) {
94725       {
94726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94727       };
94728     } catch (std::exception& e) {
94729       {
94730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94731       };
94732     } catch (Dali::DaliException e) {
94733       {
94734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94735       };
94736     } catch (...) {
94737       {
94738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94739       };
94740     }
94741   }
94742
94743   jresult = result;
94744   return jresult;
94745 }
94746
94747
94748 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
94749   unsigned long jresult ;
94750   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94751   std::size_t result;
94752
94753   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94754   {
94755     try {
94756       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
94757     } catch (std::out_of_range& e) {
94758       {
94759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94760       };
94761     } catch (std::exception& e) {
94762       {
94763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94764       };
94765     } catch (Dali::DaliException e) {
94766       {
94767         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94768       };
94769     } catch (...) {
94770       {
94771         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94772       };
94773     }
94774   }
94775
94776   jresult = (unsigned long)result;
94777   return jresult;
94778 }
94779
94780
94781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
94782   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94783   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
94784
94785   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94786   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
94787   {
94788     try {
94789       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
94790     } catch (std::out_of_range& e) {
94791       {
94792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94793       };
94794     } catch (std::exception& e) {
94795       {
94796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94797       };
94798     } catch (Dali::DaliException e) {
94799       {
94800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94801       };
94802     } catch (...) {
94803       {
94804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94805       };
94806     }
94807   }
94808
94809 }
94810
94811
94812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
94813   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94814   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
94815
94816   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94817   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
94818   {
94819     try {
94820       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
94821     } catch (std::out_of_range& e) {
94822       {
94823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94824       };
94825     } catch (std::exception& e) {
94826       {
94827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94828       };
94829     } catch (Dali::DaliException e) {
94830       {
94831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94832       };
94833     } catch (...) {
94834       {
94835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94836       };
94837     }
94838   }
94839
94840 }
94841
94842
94843 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
94844   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94845   Dali::Toolkit::PageTurnView arg2 ;
94846   Dali::Toolkit::PageTurnView *argp2 ;
94847
94848   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94849   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
94850   if (!argp2) {
94851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
94852     return ;
94853   }
94854   arg2 = *argp2;
94855   {
94856     try {
94857       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
94858     } catch (std::out_of_range& e) {
94859       {
94860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94861       };
94862     } catch (std::exception& e) {
94863       {
94864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94865       };
94866     } catch (Dali::DaliException e) {
94867       {
94868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94869       };
94870     } catch (...) {
94871       {
94872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94873       };
94874     }
94875   }
94876
94877 }
94878
94879
94880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
94881   void * jresult ;
94882   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
94883
94884   {
94885     try {
94886       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
94887     } catch (std::out_of_range& e) {
94888       {
94889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94890       };
94891     } catch (std::exception& e) {
94892       {
94893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94894       };
94895     } catch (Dali::DaliException e) {
94896       {
94897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94898       };
94899     } catch (...) {
94900       {
94901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94902       };
94903     }
94904   }
94905
94906   jresult = (void *)result;
94907   return jresult;
94908 }
94909
94910
94911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
94912   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
94913
94914   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
94915   {
94916     try {
94917       delete arg1;
94918     } catch (std::out_of_range& e) {
94919       {
94920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94921       };
94922     } catch (std::exception& e) {
94923       {
94924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94925       };
94926     } catch (Dali::DaliException e) {
94927       {
94928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94929       };
94930     } catch (...) {
94931       {
94932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94933       };
94934     }
94935   }
94936
94937 }
94938
94939
94940 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
94941   unsigned int jresult ;
94942   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
94943   bool result;
94944
94945   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
94946   {
94947     try {
94948       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);
94949     } catch (std::out_of_range& e) {
94950       {
94951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94952       };
94953     } catch (std::exception& e) {
94954       {
94955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94956       };
94957     } catch (Dali::DaliException e) {
94958       {
94959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94960       };
94961     } catch (...) {
94962       {
94963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94964       };
94965     }
94966   }
94967
94968   jresult = result;
94969   return jresult;
94970 }
94971
94972
94973 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
94974   unsigned long jresult ;
94975   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
94976   std::size_t result;
94977
94978   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
94979   {
94980     try {
94981       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);
94982     } catch (std::out_of_range& e) {
94983       {
94984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94985       };
94986     } catch (std::exception& e) {
94987       {
94988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94989       };
94990     } catch (Dali::DaliException e) {
94991       {
94992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94993       };
94994     } catch (...) {
94995       {
94996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94997       };
94998     }
94999   }
95000
95001   jresult = (unsigned long)result;
95002   return jresult;
95003 }
95004
95005
95006 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
95007   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
95008   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
95009
95010   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
95011   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
95012   {
95013     try {
95014       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
95015     } catch (std::out_of_range& e) {
95016       {
95017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95018       };
95019     } catch (std::exception& e) {
95020       {
95021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95022       };
95023     } catch (Dali::DaliException e) {
95024       {
95025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95026       };
95027     } catch (...) {
95028       {
95029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95030       };
95031     }
95032   }
95033
95034 }
95035
95036
95037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
95038   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
95039   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
95040
95041   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
95042   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
95043   {
95044     try {
95045       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
95046     } catch (std::out_of_range& e) {
95047       {
95048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95049       };
95050     } catch (std::exception& e) {
95051       {
95052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95053       };
95054     } catch (Dali::DaliException e) {
95055       {
95056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95057       };
95058     } catch (...) {
95059       {
95060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95061       };
95062     }
95063   }
95064
95065 }
95066
95067
95068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
95069   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
95070   Dali::Toolkit::ProgressBar arg2 ;
95071   float arg3 ;
95072   float arg4 ;
95073   Dali::Toolkit::ProgressBar *argp2 ;
95074
95075   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
95076   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
95077   if (!argp2) {
95078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
95079     return ;
95080   }
95081   arg2 = *argp2;
95082   arg3 = (float)jarg3;
95083   arg4 = (float)jarg4;
95084   {
95085     try {
95086       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
95087     } catch (std::out_of_range& e) {
95088       {
95089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95090       };
95091     } catch (std::exception& e) {
95092       {
95093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95094       };
95095     } catch (Dali::DaliException e) {
95096       {
95097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95098       };
95099     } catch (...) {
95100       {
95101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95102       };
95103     }
95104   }
95105
95106 }
95107
95108
95109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
95110   void * jresult ;
95111   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
95112
95113   {
95114     try {
95115       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
95116     } catch (std::out_of_range& e) {
95117       {
95118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95119       };
95120     } catch (std::exception& e) {
95121       {
95122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95123       };
95124     } catch (Dali::DaliException e) {
95125       {
95126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95127       };
95128     } catch (...) {
95129       {
95130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95131       };
95132     }
95133   }
95134
95135   jresult = (void *)result;
95136   return jresult;
95137 }
95138
95139
95140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
95141   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
95142
95143   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
95144   {
95145     try {
95146       delete arg1;
95147     } catch (std::out_of_range& e) {
95148       {
95149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95150       };
95151     } catch (std::exception& e) {
95152       {
95153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95154       };
95155     } catch (Dali::DaliException e) {
95156       {
95157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95158       };
95159     } catch (...) {
95160       {
95161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95162       };
95163     }
95164   }
95165
95166 }
95167
95168
95169 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
95170   unsigned int jresult ;
95171   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
95172   bool result;
95173
95174   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
95175   {
95176     try {
95177       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);
95178     } catch (std::out_of_range& e) {
95179       {
95180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95181       };
95182     } catch (std::exception& e) {
95183       {
95184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95185       };
95186     } catch (Dali::DaliException e) {
95187       {
95188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95189       };
95190     } catch (...) {
95191       {
95192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95193       };
95194     }
95195   }
95196
95197   jresult = result;
95198   return jresult;
95199 }
95200
95201
95202 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
95203   unsigned long jresult ;
95204   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
95205   std::size_t result;
95206
95207   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
95208   {
95209     try {
95210       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);
95211     } catch (std::out_of_range& e) {
95212       {
95213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95214       };
95215     } catch (std::exception& e) {
95216       {
95217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95218       };
95219     } catch (Dali::DaliException e) {
95220       {
95221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95222       };
95223     } catch (...) {
95224       {
95225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95226       };
95227     }
95228   }
95229
95230   jresult = (unsigned long)result;
95231   return jresult;
95232 }
95233
95234
95235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
95236   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
95237   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
95238
95239   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
95240   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
95241   {
95242     try {
95243       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
95244     } catch (std::out_of_range& e) {
95245       {
95246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95247       };
95248     } catch (std::exception& e) {
95249       {
95250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95251       };
95252     } catch (Dali::DaliException e) {
95253       {
95254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95255       };
95256     } catch (...) {
95257       {
95258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95259       };
95260     }
95261   }
95262
95263 }
95264
95265
95266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
95267   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
95268   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
95269
95270   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
95271   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
95272   {
95273     try {
95274       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
95275     } catch (std::out_of_range& e) {
95276       {
95277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95278       };
95279     } catch (std::exception& e) {
95280       {
95281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95282       };
95283     } catch (Dali::DaliException e) {
95284       {
95285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95286       };
95287     } catch (...) {
95288       {
95289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95290       };
95291     }
95292   }
95293
95294 }
95295
95296
95297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
95298   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
95299   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
95300
95301   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
95302   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
95303   if (!arg2) {
95304     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
95305     return ;
95306   }
95307   {
95308     try {
95309       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
95310     } catch (std::out_of_range& e) {
95311       {
95312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95313       };
95314     } catch (std::exception& e) {
95315       {
95316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95317       };
95318     } catch (Dali::DaliException e) {
95319       {
95320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95321       };
95322     } catch (...) {
95323       {
95324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95325       };
95326     }
95327   }
95328
95329 }
95330
95331
95332 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
95333   void * jresult ;
95334   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
95335
95336   {
95337     try {
95338       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
95339     } catch (std::out_of_range& e) {
95340       {
95341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95342       };
95343     } catch (std::exception& e) {
95344       {
95345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95346       };
95347     } catch (Dali::DaliException e) {
95348       {
95349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95350       };
95351     } catch (...) {
95352       {
95353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95354       };
95355     }
95356   }
95357
95358   jresult = (void *)result;
95359   return jresult;
95360 }
95361
95362
95363 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
95364   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
95365
95366   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
95367   {
95368     try {
95369       delete arg1;
95370     } catch (std::out_of_range& e) {
95371       {
95372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95373       };
95374     } catch (std::exception& e) {
95375       {
95376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95377       };
95378     } catch (Dali::DaliException e) {
95379       {
95380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95381       };
95382     } catch (...) {
95383       {
95384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95385       };
95386     }
95387   }
95388
95389 }
95390
95391
95392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
95393   unsigned int jresult ;
95394   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
95395   bool result;
95396
95397   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
95398   {
95399     try {
95400       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
95401     } catch (std::out_of_range& e) {
95402       {
95403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95404       };
95405     } catch (std::exception& e) {
95406       {
95407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95408       };
95409     } catch (Dali::DaliException e) {
95410       {
95411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95412       };
95413     } catch (...) {
95414       {
95415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95416       };
95417     }
95418   }
95419
95420   jresult = result;
95421   return jresult;
95422 }
95423
95424
95425 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
95426   unsigned long jresult ;
95427   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
95428   std::size_t result;
95429
95430   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
95431   {
95432     try {
95433       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
95434     } catch (std::out_of_range& e) {
95435       {
95436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95437       };
95438     } catch (std::exception& e) {
95439       {
95440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95441       };
95442     } catch (Dali::DaliException e) {
95443       {
95444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95445       };
95446     } catch (...) {
95447       {
95448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95449       };
95450     }
95451   }
95452
95453   jresult = (unsigned long)result;
95454   return jresult;
95455 }
95456
95457
95458 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
95459   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
95460   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
95461
95462   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
95463   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
95464   {
95465     try {
95466       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
95467     } catch (std::out_of_range& e) {
95468       {
95469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95470       };
95471     } catch (std::exception& e) {
95472       {
95473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95474       };
95475     } catch (Dali::DaliException e) {
95476       {
95477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95478       };
95479     } catch (...) {
95480       {
95481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95482       };
95483     }
95484   }
95485
95486 }
95487
95488
95489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
95490   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
95491   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
95492
95493   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
95494   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
95495   {
95496     try {
95497       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
95498     } catch (std::out_of_range& e) {
95499       {
95500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95501       };
95502     } catch (std::exception& e) {
95503       {
95504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95505       };
95506     } catch (Dali::DaliException e) {
95507       {
95508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95509       };
95510     } catch (...) {
95511       {
95512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95513       };
95514     }
95515   }
95516
95517 }
95518
95519
95520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
95521   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
95522   Dali::Vector2 *arg2 = 0 ;
95523
95524   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
95525   arg2 = (Dali::Vector2 *)jarg2;
95526   if (!arg2) {
95527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
95528     return ;
95529   }
95530   {
95531     try {
95532       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
95533     } catch (std::out_of_range& e) {
95534       {
95535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95536       };
95537     } catch (std::exception& e) {
95538       {
95539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95540       };
95541     } catch (Dali::DaliException e) {
95542       {
95543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95544       };
95545     } catch (...) {
95546       {
95547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95548       };
95549     }
95550   }
95551
95552 }
95553
95554
95555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
95556   void * jresult ;
95557   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
95558
95559   {
95560     try {
95561       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
95562     } catch (std::out_of_range& e) {
95563       {
95564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95565       };
95566     } catch (std::exception& e) {
95567       {
95568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95569       };
95570     } catch (Dali::DaliException e) {
95571       {
95572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95573       };
95574     } catch (...) {
95575       {
95576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95577       };
95578     }
95579   }
95580
95581   jresult = (void *)result;
95582   return jresult;
95583 }
95584
95585
95586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
95587   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
95588
95589   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
95590   {
95591     try {
95592       delete arg1;
95593     } catch (std::out_of_range& e) {
95594       {
95595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95596       };
95597     } catch (std::exception& e) {
95598       {
95599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95600       };
95601     } catch (Dali::DaliException e) {
95602       {
95603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95604       };
95605     } catch (...) {
95606       {
95607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95608       };
95609     }
95610   }
95611
95612 }
95613
95614
95615
95616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
95617   unsigned int jresult ;
95618   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
95619   bool result;
95620
95621   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
95622   {
95623     try {
95624       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);
95625     } catch (std::out_of_range& e) {
95626       {
95627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95628       };
95629     } catch (std::exception& e) {
95630       {
95631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95632       };
95633     } catch (Dali::DaliException e) {
95634       {
95635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95636       };
95637     } catch (...) {
95638       {
95639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95640       };
95641     }
95642   }
95643
95644   jresult = result;
95645   return jresult;
95646 }
95647
95648
95649 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
95650   unsigned long jresult ;
95651   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
95652   std::size_t result;
95653
95654   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
95655   {
95656     try {
95657       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);
95658     } catch (std::out_of_range& e) {
95659       {
95660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95661       };
95662     } catch (std::exception& e) {
95663       {
95664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95665       };
95666     } catch (Dali::DaliException e) {
95667       {
95668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95669       };
95670     } catch (...) {
95671       {
95672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95673       };
95674     }
95675   }
95676
95677   jresult = (unsigned long)result;
95678   return jresult;
95679 }
95680
95681
95682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
95683   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
95684   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
95685
95686   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
95687   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
95688   {
95689     try {
95690       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
95691     } catch (std::out_of_range& e) {
95692       {
95693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95694       };
95695     } catch (std::exception& e) {
95696       {
95697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95698       };
95699     } catch (Dali::DaliException e) {
95700       {
95701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95702       };
95703     } catch (...) {
95704       {
95705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95706       };
95707     }
95708   }
95709
95710 }
95711
95712
95713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
95714   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
95715   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
95716
95717   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
95718   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
95719   {
95720     try {
95721       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
95722     } catch (std::out_of_range& e) {
95723       {
95724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95725       };
95726     } catch (std::exception& e) {
95727       {
95728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95729       };
95730     } catch (Dali::DaliException e) {
95731       {
95732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95733       };
95734     } catch (...) {
95735       {
95736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95737       };
95738     }
95739   }
95740
95741 }
95742
95743
95744 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
95745   unsigned int jresult ;
95746   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
95747   Dali::Toolkit::Control arg2 ;
95748   Dali::KeyEvent *arg3 = 0 ;
95749   Dali::Toolkit::Control *argp2 ;
95750   bool result;
95751
95752   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
95753   argp2 = (Dali::Toolkit::Control *)jarg2;
95754   if (!argp2) {
95755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95756     return 0;
95757   }
95758   arg2 = *argp2;
95759   arg3 = (Dali::KeyEvent *)jarg3;
95760   if (!arg3) {
95761     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
95762     return 0;
95763   }
95764   {
95765     try {
95766       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);
95767     } catch (std::out_of_range& e) {
95768       {
95769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95770       };
95771     } catch (std::exception& e) {
95772       {
95773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95774       };
95775     } catch (Dali::DaliException e) {
95776       {
95777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95778       };
95779     } catch (...) {
95780       {
95781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95782       };
95783     }
95784   }
95785
95786   jresult = result;
95787   return jresult;
95788 }
95789
95790
95791 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
95792   void * jresult ;
95793   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
95794
95795   {
95796     try {
95797       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
95798     } catch (std::out_of_range& e) {
95799       {
95800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95801       };
95802     } catch (std::exception& e) {
95803       {
95804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95805       };
95806     } catch (Dali::DaliException e) {
95807       {
95808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95809       };
95810     } catch (...) {
95811       {
95812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95813       };
95814     }
95815   }
95816
95817   jresult = (void *)result;
95818   return jresult;
95819 }
95820
95821
95822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
95823   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
95824
95825   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
95826   {
95827     try {
95828       delete arg1;
95829     } catch (std::out_of_range& e) {
95830       {
95831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95832       };
95833     } catch (std::exception& e) {
95834       {
95835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95836       };
95837     } catch (Dali::DaliException e) {
95838       {
95839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95840       };
95841     } catch (...) {
95842       {
95843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95844       };
95845     }
95846   }
95847
95848 }
95849
95850
95851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
95852   unsigned int jresult ;
95853   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95854   bool result;
95855
95856   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95857   {
95858     try {
95859       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95860     } catch (std::out_of_range& e) {
95861       {
95862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95863       };
95864     } catch (std::exception& e) {
95865       {
95866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95867       };
95868     } catch (Dali::DaliException e) {
95869       {
95870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95871       };
95872     } catch (...) {
95873       {
95874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95875       };
95876     }
95877   }
95878
95879   jresult = result;
95880   return jresult;
95881 }
95882
95883
95884 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
95885   unsigned long jresult ;
95886   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95887   std::size_t result;
95888
95889   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95890   {
95891     try {
95892       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95893     } catch (std::out_of_range& e) {
95894       {
95895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95896       };
95897     } catch (std::exception& e) {
95898       {
95899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95900       };
95901     } catch (Dali::DaliException e) {
95902       {
95903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95904       };
95905     } catch (...) {
95906       {
95907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95908       };
95909     }
95910   }
95911
95912   jresult = (unsigned long)result;
95913   return jresult;
95914 }
95915
95916
95917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
95918   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95919   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95920
95921   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95922   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95923   {
95924     try {
95925       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95926     } catch (std::out_of_range& e) {
95927       {
95928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95929       };
95930     } catch (std::exception& e) {
95931       {
95932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95933       };
95934     } catch (Dali::DaliException e) {
95935       {
95936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95937       };
95938     } catch (...) {
95939       {
95940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95941       };
95942     }
95943   }
95944
95945 }
95946
95947
95948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
95949   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95950   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95951
95952   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95953   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95954   {
95955     try {
95956       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95957     } catch (std::out_of_range& e) {
95958       {
95959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95960       };
95961     } catch (std::exception& e) {
95962       {
95963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95964       };
95965     } catch (Dali::DaliException e) {
95966       {
95967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95968       };
95969     } catch (...) {
95970       {
95971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95972       };
95973     }
95974   }
95975
95976 }
95977
95978
95979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
95980   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95981   Dali::Toolkit::Control arg2 ;
95982   Dali::Toolkit::Control *argp2 ;
95983
95984   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95985   argp2 = (Dali::Toolkit::Control *)jarg2;
95986   if (!argp2) {
95987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95988     return ;
95989   }
95990   arg2 = *argp2;
95991   {
95992     try {
95993       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95994     } catch (std::out_of_range& e) {
95995       {
95996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95997       };
95998     } catch (std::exception& e) {
95999       {
96000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96001       };
96002     } catch (Dali::DaliException e) {
96003       {
96004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96005       };
96006     } catch (...) {
96007       {
96008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96009       };
96010     }
96011   }
96012
96013 }
96014
96015
96016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
96017   void * jresult ;
96018   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
96019
96020   {
96021     try {
96022       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
96023     } catch (std::out_of_range& e) {
96024       {
96025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96026       };
96027     } catch (std::exception& e) {
96028       {
96029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96030       };
96031     } catch (Dali::DaliException e) {
96032       {
96033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96034       };
96035     } catch (...) {
96036       {
96037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96038       };
96039     }
96040   }
96041
96042   jresult = (void *)result;
96043   return jresult;
96044 }
96045
96046
96047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
96048   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
96049
96050   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
96051   {
96052     try {
96053       delete arg1;
96054     } catch (std::out_of_range& e) {
96055       {
96056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96057       };
96058     } catch (std::exception& e) {
96059       {
96060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96061       };
96062     } catch (Dali::DaliException e) {
96063       {
96064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96065       };
96066     } catch (...) {
96067       {
96068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96069       };
96070     }
96071   }
96072
96073 }
96074
96075
96076 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
96077   unsigned int jresult ;
96078   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
96079   bool result;
96080
96081   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
96082   {
96083     try {
96084       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
96085     } catch (std::out_of_range& e) {
96086       {
96087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96088       };
96089     } catch (std::exception& e) {
96090       {
96091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96092       };
96093     } catch (Dali::DaliException e) {
96094       {
96095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96096       };
96097     } catch (...) {
96098       {
96099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96100       };
96101     }
96102   }
96103
96104   jresult = result;
96105   return jresult;
96106 }
96107
96108
96109 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
96110   unsigned long jresult ;
96111   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
96112   std::size_t result;
96113
96114   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
96115   {
96116     try {
96117       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
96118     } catch (std::out_of_range& e) {
96119       {
96120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96121       };
96122     } catch (std::exception& e) {
96123       {
96124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96125       };
96126     } catch (Dali::DaliException e) {
96127       {
96128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96129       };
96130     } catch (...) {
96131       {
96132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96133       };
96134     }
96135   }
96136
96137   jresult = (unsigned long)result;
96138   return jresult;
96139 }
96140
96141
96142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
96143   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
96144   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
96145
96146   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
96147   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
96148   {
96149     try {
96150       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
96151     } catch (std::out_of_range& e) {
96152       {
96153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96154       };
96155     } catch (std::exception& e) {
96156       {
96157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96158       };
96159     } catch (Dali::DaliException e) {
96160       {
96161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96162       };
96163     } catch (...) {
96164       {
96165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96166       };
96167     }
96168   }
96169
96170 }
96171
96172
96173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
96174   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
96175   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
96176
96177   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
96178   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
96179   {
96180     try {
96181       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
96182     } catch (std::out_of_range& e) {
96183       {
96184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96185       };
96186     } catch (std::exception& e) {
96187       {
96188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96189       };
96190     } catch (Dali::DaliException e) {
96191       {
96192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96193       };
96194     } catch (...) {
96195       {
96196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96197       };
96198     }
96199   }
96200
96201 }
96202
96203
96204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
96205   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
96206   Dali::Toolkit::VideoView *arg2 = 0 ;
96207
96208   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
96209   arg2 = (Dali::Toolkit::VideoView *)jarg2;
96210   if (!arg2) {
96211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
96212     return ;
96213   }
96214   {
96215     try {
96216       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
96217     } catch (std::out_of_range& e) {
96218       {
96219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96220       };
96221     } catch (std::exception& e) {
96222       {
96223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96224       };
96225     } catch (Dali::DaliException e) {
96226       {
96227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96228       };
96229     } catch (...) {
96230       {
96231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96232       };
96233     }
96234   }
96235
96236 }
96237
96238
96239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
96240   void * jresult ;
96241   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
96242
96243   {
96244     try {
96245       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
96246     } catch (std::out_of_range& e) {
96247       {
96248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96249       };
96250     } catch (std::exception& e) {
96251       {
96252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96253       };
96254     } catch (Dali::DaliException e) {
96255       {
96256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96257       };
96258     } catch (...) {
96259       {
96260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96261       };
96262     }
96263   }
96264
96265   jresult = (void *)result;
96266   return jresult;
96267 }
96268
96269
96270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
96271   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
96272
96273   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
96274   {
96275     try {
96276       delete arg1;
96277     } catch (std::out_of_range& e) {
96278       {
96279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96280       };
96281     } catch (std::exception& e) {
96282       {
96283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96284       };
96285     } catch (Dali::DaliException e) {
96286       {
96287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96288       };
96289     } catch (...) {
96290       {
96291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96292       };
96293     }
96294   }
96295
96296 }
96297
96298
96299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
96300   unsigned int jresult ;
96301   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
96302   bool result;
96303
96304   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
96305   {
96306     try {
96307       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
96308     } catch (std::out_of_range& e) {
96309       {
96310         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96311       };
96312     } catch (std::exception& e) {
96313       {
96314         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96315       };
96316     } catch (Dali::DaliException e) {
96317       {
96318         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96319       };
96320     } catch (...) {
96321       {
96322         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96323       };
96324     }
96325   }
96326
96327   jresult = result;
96328   return jresult;
96329 }
96330
96331
96332 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
96333   unsigned long jresult ;
96334   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
96335   std::size_t result;
96336
96337   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
96338   {
96339     try {
96340       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
96341     } catch (std::out_of_range& e) {
96342       {
96343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96344       };
96345     } catch (std::exception& e) {
96346       {
96347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96348       };
96349     } catch (Dali::DaliException e) {
96350       {
96351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96352       };
96353     } catch (...) {
96354       {
96355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96356       };
96357     }
96358   }
96359
96360   jresult = (unsigned long)result;
96361   return jresult;
96362 }
96363
96364
96365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
96366   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
96367   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
96368
96369   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
96370   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
96371   {
96372     try {
96373       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
96374     } catch (std::out_of_range& e) {
96375       {
96376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96377       };
96378     } catch (std::exception& e) {
96379       {
96380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96381       };
96382     } catch (Dali::DaliException e) {
96383       {
96384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96385       };
96386     } catch (...) {
96387       {
96388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96389       };
96390     }
96391   }
96392
96393 }
96394
96395
96396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
96397   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
96398   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
96399
96400   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
96401   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
96402   {
96403     try {
96404       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
96405     } catch (std::out_of_range& e) {
96406       {
96407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96408       };
96409     } catch (std::exception& e) {
96410       {
96411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96412       };
96413     } catch (Dali::DaliException e) {
96414       {
96415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96416       };
96417     } catch (...) {
96418       {
96419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96420       };
96421     }
96422   }
96423
96424 }
96425
96426
96427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
96428   unsigned int jresult ;
96429   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
96430   Dali::Toolkit::Slider arg2 ;
96431   float arg3 ;
96432   Dali::Toolkit::Slider *argp2 ;
96433   bool result;
96434
96435   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
96436   argp2 = (Dali::Toolkit::Slider *)jarg2;
96437   if (!argp2) {
96438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
96439     return 0;
96440   }
96441   arg2 = *argp2;
96442   arg3 = (float)jarg3;
96443   {
96444     try {
96445       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
96446     } catch (std::out_of_range& e) {
96447       {
96448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96449       };
96450     } catch (std::exception& e) {
96451       {
96452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96453       };
96454     } catch (Dali::DaliException e) {
96455       {
96456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96457       };
96458     } catch (...) {
96459       {
96460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96461       };
96462     }
96463   }
96464
96465   jresult = result;
96466   return jresult;
96467 }
96468
96469
96470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
96471   void * jresult ;
96472   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
96473
96474   {
96475     try {
96476       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
96477     } catch (std::out_of_range& e) {
96478       {
96479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96480       };
96481     } catch (std::exception& e) {
96482       {
96483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96484       };
96485     } catch (Dali::DaliException e) {
96486       {
96487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96488       };
96489     } catch (...) {
96490       {
96491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96492       };
96493     }
96494   }
96495
96496   jresult = (void *)result;
96497   return jresult;
96498 }
96499
96500
96501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
96502   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
96503
96504   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
96505   {
96506     try {
96507       delete arg1;
96508     } catch (std::out_of_range& e) {
96509       {
96510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96511       };
96512     } catch (std::exception& e) {
96513       {
96514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96515       };
96516     } catch (Dali::DaliException e) {
96517       {
96518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96519       };
96520     } catch (...) {
96521       {
96522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96523       };
96524     }
96525   }
96526
96527 }
96528
96529
96530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
96531   unsigned int jresult ;
96532   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
96533   bool result;
96534
96535   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
96536   {
96537     try {
96538       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
96539     } catch (std::out_of_range& e) {
96540       {
96541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96542       };
96543     } catch (std::exception& e) {
96544       {
96545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96546       };
96547     } catch (Dali::DaliException e) {
96548       {
96549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96550       };
96551     } catch (...) {
96552       {
96553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96554       };
96555     }
96556   }
96557
96558   jresult = result;
96559   return jresult;
96560 }
96561
96562
96563 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
96564   unsigned long jresult ;
96565   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
96566   std::size_t result;
96567
96568   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
96569   {
96570     try {
96571       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
96572     } catch (std::out_of_range& e) {
96573       {
96574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96575       };
96576     } catch (std::exception& e) {
96577       {
96578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96579       };
96580     } catch (Dali::DaliException e) {
96581       {
96582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96583       };
96584     } catch (...) {
96585       {
96586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96587       };
96588     }
96589   }
96590
96591   jresult = (unsigned long)result;
96592   return jresult;
96593 }
96594
96595
96596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
96597   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
96598   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
96599
96600   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
96601   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
96602   {
96603     try {
96604       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
96605     } catch (std::out_of_range& e) {
96606       {
96607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96608       };
96609     } catch (std::exception& e) {
96610       {
96611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96612       };
96613     } catch (Dali::DaliException e) {
96614       {
96615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96616       };
96617     } catch (...) {
96618       {
96619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96620       };
96621     }
96622   }
96623
96624 }
96625
96626
96627 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
96628   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
96629   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
96630
96631   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
96632   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
96633   {
96634     try {
96635       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
96636     } catch (std::out_of_range& e) {
96637       {
96638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96639       };
96640     } catch (std::exception& e) {
96641       {
96642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96643       };
96644     } catch (Dali::DaliException e) {
96645       {
96646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96647       };
96648     } catch (...) {
96649       {
96650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96651       };
96652     }
96653   }
96654
96655 }
96656
96657
96658 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
96659   unsigned int jresult ;
96660   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
96661   Dali::Toolkit::Slider arg2 ;
96662   int arg3 ;
96663   Dali::Toolkit::Slider *argp2 ;
96664   bool result;
96665
96666   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
96667   argp2 = (Dali::Toolkit::Slider *)jarg2;
96668   if (!argp2) {
96669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
96670     return 0;
96671   }
96672   arg2 = *argp2;
96673   arg3 = (int)jarg3;
96674   {
96675     try {
96676       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
96677     } catch (std::out_of_range& e) {
96678       {
96679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96680       };
96681     } catch (std::exception& e) {
96682       {
96683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96684       };
96685     } catch (Dali::DaliException e) {
96686       {
96687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96688       };
96689     } catch (...) {
96690       {
96691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96692       };
96693     }
96694   }
96695
96696   jresult = result;
96697   return jresult;
96698 }
96699
96700
96701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
96702   void * jresult ;
96703   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
96704
96705   {
96706     try {
96707       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
96708     } catch (std::out_of_range& e) {
96709       {
96710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96711       };
96712     } catch (std::exception& e) {
96713       {
96714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96715       };
96716     } catch (Dali::DaliException e) {
96717       {
96718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96719       };
96720     } catch (...) {
96721       {
96722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96723       };
96724     }
96725   }
96726
96727   jresult = (void *)result;
96728   return jresult;
96729 }
96730
96731
96732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
96733   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
96734
96735   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
96736   {
96737     try {
96738       delete arg1;
96739     } catch (std::out_of_range& e) {
96740       {
96741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96742       };
96743     } catch (std::exception& e) {
96744       {
96745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96746       };
96747     } catch (Dali::DaliException e) {
96748       {
96749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96750       };
96751     } catch (...) {
96752       {
96753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96754       };
96755     }
96756   }
96757
96758 }
96759
96760
96761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
96762   void * jresult ;
96763   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
96764
96765   {
96766     try {
96767       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
96768     } catch (std::out_of_range& e) {
96769       {
96770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96771       };
96772     } catch (std::exception& e) {
96773       {
96774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96775       };
96776     } catch (Dali::DaliException e) {
96777       {
96778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96779       };
96780     } catch (...) {
96781       {
96782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96783       };
96784     }
96785   }
96786
96787   jresult = (void *)result;
96788   return jresult;
96789 }
96790
96791
96792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
96793   void * jresult ;
96794   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
96795   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
96796
96797   arg1 = (Dali::Toolkit::Ruler *)jarg1;
96798   {
96799     try {
96800       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
96801     } catch (std::out_of_range& e) {
96802       {
96803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96804       };
96805     } catch (std::exception& e) {
96806       {
96807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96808       };
96809     } catch (Dali::DaliException e) {
96810       {
96811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96812       };
96813     } catch (...) {
96814       {
96815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96816       };
96817     }
96818   }
96819
96820   jresult = (void *)result;
96821   return jresult;
96822 }
96823
96824
96825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
96826   void * jresult ;
96827   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
96828   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
96829
96830   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96831   if (!arg1) {
96832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
96833     return 0;
96834   }
96835   {
96836     try {
96837       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
96838     } catch (std::out_of_range& e) {
96839       {
96840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96841       };
96842     } catch (std::exception& e) {
96843       {
96844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96845       };
96846     } catch (Dali::DaliException e) {
96847       {
96848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96849       };
96850     } catch (...) {
96851       {
96852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96853       };
96854     }
96855   }
96856
96857   jresult = (void *)result;
96858   return jresult;
96859 }
96860
96861
96862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
96863   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96864
96865   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96866   {
96867     try {
96868       delete arg1;
96869     } catch (std::out_of_range& e) {
96870       {
96871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96872       };
96873     } catch (std::exception& e) {
96874       {
96875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96876       };
96877     } catch (Dali::DaliException e) {
96878       {
96879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
96880       };
96881     } catch (...) {
96882       {
96883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96884       };
96885     }
96886   }
96887
96888 }
96889
96890
96891 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
96892   void * jresult ;
96893   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96894   Dali::Toolkit::Ruler *result = 0 ;
96895
96896   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96897   {
96898     try {
96899       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
96900     } catch (std::out_of_range& e) {
96901       {
96902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96903       };
96904     } catch (std::exception& e) {
96905       {
96906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96907       };
96908     } catch (Dali::DaliException e) {
96909       {
96910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96911       };
96912     } catch (...) {
96913       {
96914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96915       };
96916     }
96917   }
96918
96919   jresult = (void *)result;
96920   return jresult;
96921 }
96922
96923
96924 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
96925   void * jresult ;
96926   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96927   Dali::Toolkit::Ruler *result = 0 ;
96928
96929   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96930   {
96931     try {
96932       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
96933     } catch (std::out_of_range& e) {
96934       {
96935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96936       };
96937     } catch (std::exception& e) {
96938       {
96939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96940       };
96941     } catch (Dali::DaliException e) {
96942       {
96943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96944       };
96945     } catch (...) {
96946       {
96947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96948       };
96949     }
96950   }
96951
96952   jresult = (void *)result;
96953   return jresult;
96954 }
96955
96956
96957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
96958   void * jresult ;
96959   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96960   Dali::Toolkit::Ruler *result = 0 ;
96961
96962   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96963   {
96964     try {
96965       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
96966     } catch (std::out_of_range& e) {
96967       {
96968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96969       };
96970     } catch (std::exception& e) {
96971       {
96972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96973       };
96974     } catch (Dali::DaliException e) {
96975       {
96976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
96977       };
96978     } catch (...) {
96979       {
96980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96981       };
96982     }
96983   }
96984
96985   jresult = (void *)result;
96986   return jresult;
96987 }
96988
96989
96990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
96991   void * jresult ;
96992   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
96993   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
96994   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
96995
96996   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
96997   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
96998   if (!arg2) {
96999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
97000     return 0;
97001   }
97002   {
97003     try {
97004       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
97005     } catch (std::out_of_range& e) {
97006       {
97007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97008       };
97009     } catch (std::exception& e) {
97010       {
97011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97012       };
97013     } catch (Dali::DaliException e) {
97014       {
97015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97016       };
97017     } catch (...) {
97018       {
97019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97020       };
97021     }
97022   }
97023
97024   jresult = (void *)result;
97025   return jresult;
97026 }
97027
97028
97029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
97030   void * jresult ;
97031   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97032   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
97033   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
97034
97035   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97036   arg2 = (Dali::Toolkit::Ruler *)jarg2;
97037   {
97038     try {
97039       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
97040     } catch (std::out_of_range& e) {
97041       {
97042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97043       };
97044     } catch (std::exception& e) {
97045       {
97046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97047       };
97048     } catch (Dali::DaliException e) {
97049       {
97050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97051       };
97052     } catch (...) {
97053       {
97054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97055       };
97056     }
97057   }
97058
97059   jresult = (void *)result;
97060   return jresult;
97061 }
97062
97063
97064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
97065   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97066
97067   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97068   {
97069     try {
97070       (arg1)->Reset();
97071     } catch (std::out_of_range& e) {
97072       {
97073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97074       };
97075     } catch (std::exception& e) {
97076       {
97077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97078       };
97079     } catch (Dali::DaliException e) {
97080       {
97081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97082       };
97083     } catch (...) {
97084       {
97085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97086       };
97087     }
97088   }
97089
97090 }
97091
97092
97093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
97094   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97095   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
97096
97097   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97098   arg2 = (Dali::Toolkit::Ruler *)jarg2;
97099   {
97100     try {
97101       (arg1)->Reset(arg2);
97102     } catch (std::out_of_range& e) {
97103       {
97104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97105       };
97106     } catch (std::exception& e) {
97107       {
97108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97109       };
97110     } catch (Dali::DaliException e) {
97111       {
97112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97113       };
97114     } catch (...) {
97115       {
97116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97117       };
97118     }
97119   }
97120
97121 }
97122
97123
97124 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
97125   void * jresult ;
97126   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97127   Dali::Toolkit::Ruler *result = 0 ;
97128
97129   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97130   {
97131     try {
97132       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
97133     } catch (std::out_of_range& e) {
97134       {
97135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97136       };
97137     } catch (std::exception& e) {
97138       {
97139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97140       };
97141     } catch (Dali::DaliException e) {
97142       {
97143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97144       };
97145     } catch (...) {
97146       {
97147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97148       };
97149     }
97150   }
97151
97152   jresult = (void *)result;
97153   return jresult;
97154 }
97155
97156
97157 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
97158   float jresult ;
97159   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97160   float arg2 ;
97161   float arg3 ;
97162   float result;
97163
97164   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97165   arg2 = (float)jarg2;
97166   arg3 = (float)jarg3;
97167   {
97168     try {
97169       result = (float)(*arg1)->Snap(arg2,arg3);
97170     } catch (std::out_of_range& e) {
97171       {
97172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97173       };
97174     } catch (std::exception& e) {
97175       {
97176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97177       };
97178     } catch (Dali::DaliException e) {
97179       {
97180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97181       };
97182     } catch (...) {
97183       {
97184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97185       };
97186     }
97187   }
97188
97189   jresult = result;
97190   return jresult;
97191 }
97192
97193
97194 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
97195   float jresult ;
97196   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97197   float arg2 ;
97198   float result;
97199
97200   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97201   arg2 = (float)jarg2;
97202   {
97203     try {
97204       result = (float)(*arg1)->Snap(arg2);
97205     } catch (std::out_of_range& e) {
97206       {
97207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97208       };
97209     } catch (std::exception& e) {
97210       {
97211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97212       };
97213     } catch (Dali::DaliException e) {
97214       {
97215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97216       };
97217     } catch (...) {
97218       {
97219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97220       };
97221     }
97222   }
97223
97224   jresult = result;
97225   return jresult;
97226 }
97227
97228
97229 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
97230   float jresult ;
97231   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97232   unsigned int arg2 ;
97233   unsigned int *arg3 = 0 ;
97234   bool arg4 ;
97235   float result;
97236
97237   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97238   arg2 = (unsigned int)jarg2;
97239   arg3 = (unsigned int *)jarg3;
97240   arg4 = jarg4 ? true : false;
97241   {
97242     try {
97243       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
97244     } catch (std::out_of_range& e) {
97245       {
97246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97247       };
97248     } catch (std::exception& e) {
97249       {
97250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97251       };
97252     } catch (Dali::DaliException e) {
97253       {
97254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97255       };
97256     } catch (...) {
97257       {
97258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97259       };
97260     }
97261   }
97262
97263   jresult = result;
97264   return jresult;
97265 }
97266
97267
97268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
97269   unsigned int jresult ;
97270   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97271   float arg2 ;
97272   bool arg3 ;
97273   unsigned int result;
97274
97275   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97276   arg2 = (float)jarg2;
97277   arg3 = jarg3 ? true : false;
97278   {
97279     try {
97280       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
97281     } catch (std::out_of_range& e) {
97282       {
97283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97284       };
97285     } catch (std::exception& e) {
97286       {
97287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97288       };
97289     } catch (Dali::DaliException e) {
97290       {
97291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97292       };
97293     } catch (...) {
97294       {
97295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97296       };
97297     }
97298   }
97299
97300   jresult = result;
97301   return jresult;
97302 }
97303
97304
97305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
97306   unsigned int jresult ;
97307   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97308   unsigned int result;
97309
97310   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97311   {
97312     try {
97313       result = (unsigned int)(*arg1)->GetTotalPages();
97314     } catch (std::out_of_range& e) {
97315       {
97316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97317       };
97318     } catch (std::exception& e) {
97319       {
97320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97321       };
97322     } catch (Dali::DaliException e) {
97323       {
97324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97325       };
97326     } catch (...) {
97327       {
97328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97329       };
97330     }
97331   }
97332
97333   jresult = result;
97334   return jresult;
97335 }
97336
97337
97338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
97339   int jresult ;
97340   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97341   Dali::Toolkit::Ruler::RulerType result;
97342
97343   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97344   {
97345     try {
97346       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
97347     } catch (std::out_of_range& e) {
97348       {
97349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97350       };
97351     } catch (std::exception& e) {
97352       {
97353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97354       };
97355     } catch (Dali::DaliException e) {
97356       {
97357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97358       };
97359     } catch (...) {
97360       {
97361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97362       };
97363     }
97364   }
97365
97366   jresult = (int)result;
97367   return jresult;
97368 }
97369
97370
97371 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
97372   unsigned int jresult ;
97373   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97374   bool result;
97375
97376   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97377   {
97378     try {
97379       result = (bool)(*arg1)->IsEnabled();
97380     } catch (std::out_of_range& e) {
97381       {
97382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97383       };
97384     } catch (std::exception& e) {
97385       {
97386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97387       };
97388     } catch (Dali::DaliException e) {
97389       {
97390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97391       };
97392     } catch (...) {
97393       {
97394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97395       };
97396     }
97397   }
97398
97399   jresult = result;
97400   return jresult;
97401 }
97402
97403
97404 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
97405   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97406
97407   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97408   {
97409     try {
97410       (*arg1)->Enable();
97411     } catch (std::out_of_range& e) {
97412       {
97413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97414       };
97415     } catch (std::exception& e) {
97416       {
97417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97418       };
97419     } catch (Dali::DaliException e) {
97420       {
97421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97422       };
97423     } catch (...) {
97424       {
97425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97426       };
97427     }
97428   }
97429
97430 }
97431
97432
97433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
97434   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97435
97436   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97437   {
97438     try {
97439       (*arg1)->Disable();
97440     } catch (std::out_of_range& e) {
97441       {
97442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97443       };
97444     } catch (std::exception& e) {
97445       {
97446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97447       };
97448     } catch (Dali::DaliException e) {
97449       {
97450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97451       };
97452     } catch (...) {
97453       {
97454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97455       };
97456     }
97457   }
97458
97459 }
97460
97461
97462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
97463   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97464   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
97465   Dali::Toolkit::RulerDomain *argp2 ;
97466
97467   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97468   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
97469   if (!argp2) {
97470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
97471     return ;
97472   }
97473   arg2 = *argp2;
97474   {
97475     try {
97476       (*arg1)->SetDomain(arg2);
97477     } catch (std::out_of_range& e) {
97478       {
97479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97480       };
97481     } catch (std::exception& e) {
97482       {
97483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97484       };
97485     } catch (Dali::DaliException e) {
97486       {
97487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97488       };
97489     } catch (...) {
97490       {
97491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97492       };
97493     }
97494   }
97495
97496 }
97497
97498
97499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
97500   void * jresult ;
97501   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97502   Dali::Toolkit::RulerDomain *result = 0 ;
97503
97504   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97505   {
97506     try {
97507       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
97508     } catch (std::out_of_range& e) {
97509       {
97510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97511       };
97512     } catch (std::exception& e) {
97513       {
97514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97515       };
97516     } catch (Dali::DaliException e) {
97517       {
97518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97519       };
97520     } catch (...) {
97521       {
97522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97523       };
97524     }
97525   }
97526
97527   jresult = (void *)result;
97528   return jresult;
97529 }
97530
97531
97532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
97533   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97534
97535   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97536   {
97537     try {
97538       (*arg1)->DisableDomain();
97539     } catch (std::out_of_range& e) {
97540       {
97541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97542       };
97543     } catch (std::exception& e) {
97544       {
97545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97546       };
97547     } catch (Dali::DaliException e) {
97548       {
97549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97550       };
97551     } catch (...) {
97552       {
97553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97554       };
97555     }
97556   }
97557
97558 }
97559
97560
97561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
97562   float jresult ;
97563   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97564   float arg2 ;
97565   float arg3 ;
97566   float arg4 ;
97567   float result;
97568
97569   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97570   arg2 = (float)jarg2;
97571   arg3 = (float)jarg3;
97572   arg4 = (float)jarg4;
97573   {
97574     try {
97575       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
97576     } catch (std::out_of_range& e) {
97577       {
97578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97579       };
97580     } catch (std::exception& e) {
97581       {
97582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97583       };
97584     } catch (Dali::DaliException e) {
97585       {
97586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97587       };
97588     } catch (...) {
97589       {
97590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97591       };
97592     }
97593   }
97594
97595   jresult = result;
97596   return jresult;
97597 }
97598
97599
97600 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
97601   float jresult ;
97602   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97603   float arg2 ;
97604   float arg3 ;
97605   float result;
97606
97607   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97608   arg2 = (float)jarg2;
97609   arg3 = (float)jarg3;
97610   {
97611     try {
97612       result = (float)(*arg1)->Clamp(arg2,arg3);
97613     } catch (std::out_of_range& e) {
97614       {
97615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97616       };
97617     } catch (std::exception& e) {
97618       {
97619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97620       };
97621     } catch (Dali::DaliException e) {
97622       {
97623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97624       };
97625     } catch (...) {
97626       {
97627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97628       };
97629     }
97630   }
97631
97632   jresult = result;
97633   return jresult;
97634 }
97635
97636
97637 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
97638   float jresult ;
97639   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97640   float arg2 ;
97641   float result;
97642
97643   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97644   arg2 = (float)jarg2;
97645   {
97646     try {
97647       result = (float)(*arg1)->Clamp(arg2);
97648     } catch (std::out_of_range& e) {
97649       {
97650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97651       };
97652     } catch (std::exception& e) {
97653       {
97654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97655       };
97656     } catch (Dali::DaliException e) {
97657       {
97658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97659       };
97660     } catch (...) {
97661       {
97662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97663       };
97664     }
97665   }
97666
97667   jresult = result;
97668   return jresult;
97669 }
97670
97671
97672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
97673   float jresult ;
97674   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97675   float arg2 ;
97676   float arg3 ;
97677   float arg4 ;
97678   Dali::Toolkit::ClampState *arg5 = 0 ;
97679   float result;
97680
97681   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97682   arg2 = (float)jarg2;
97683   arg3 = (float)jarg3;
97684   arg4 = (float)jarg4;
97685   arg5 = (Dali::Toolkit::ClampState *)jarg5;
97686   if (!arg5) {
97687     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
97688     return 0;
97689   }
97690   {
97691     try {
97692       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
97693     } catch (std::out_of_range& e) {
97694       {
97695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97696       };
97697     } catch (std::exception& e) {
97698       {
97699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97700       };
97701     } catch (Dali::DaliException e) {
97702       {
97703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97704       };
97705     } catch (...) {
97706       {
97707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97708       };
97709     }
97710   }
97711
97712   jresult = result;
97713   return jresult;
97714 }
97715
97716
97717 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
97718   float jresult ;
97719   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97720   float arg2 ;
97721   float arg3 ;
97722   float arg4 ;
97723   float arg5 ;
97724   float result;
97725
97726   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97727   arg2 = (float)jarg2;
97728   arg3 = (float)jarg3;
97729   arg4 = (float)jarg4;
97730   arg5 = (float)jarg5;
97731   {
97732     try {
97733       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
97734     } catch (std::out_of_range& e) {
97735       {
97736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97737       };
97738     } catch (std::exception& e) {
97739       {
97740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97741       };
97742     } catch (Dali::DaliException e) {
97743       {
97744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97745       };
97746     } catch (...) {
97747       {
97748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97749       };
97750     }
97751   }
97752
97753   jresult = result;
97754   return jresult;
97755 }
97756
97757
97758 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
97759   float jresult ;
97760   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97761   float arg2 ;
97762   float arg3 ;
97763   float arg4 ;
97764   float result;
97765
97766   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97767   arg2 = (float)jarg2;
97768   arg3 = (float)jarg3;
97769   arg4 = (float)jarg4;
97770   {
97771     try {
97772       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
97773     } catch (std::out_of_range& e) {
97774       {
97775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97776       };
97777     } catch (std::exception& e) {
97778       {
97779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97780       };
97781     } catch (Dali::DaliException e) {
97782       {
97783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97784       };
97785     } catch (...) {
97786       {
97787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97788       };
97789     }
97790   }
97791
97792   jresult = result;
97793   return jresult;
97794 }
97795
97796
97797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
97798   float jresult ;
97799   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97800   float arg2 ;
97801   float arg3 ;
97802   float result;
97803
97804   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97805   arg2 = (float)jarg2;
97806   arg3 = (float)jarg3;
97807   {
97808     try {
97809       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
97810     } catch (std::out_of_range& e) {
97811       {
97812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97813       };
97814     } catch (std::exception& e) {
97815       {
97816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97817       };
97818     } catch (Dali::DaliException e) {
97819       {
97820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97821       };
97822     } catch (...) {
97823       {
97824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97825       };
97826     }
97827   }
97828
97829   jresult = result;
97830   return jresult;
97831 }
97832
97833
97834 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
97835   float jresult ;
97836   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97837   float arg2 ;
97838   float result;
97839
97840   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97841   arg2 = (float)jarg2;
97842   {
97843     try {
97844       result = (float)(*arg1)->SnapAndClamp(arg2);
97845     } catch (std::out_of_range& e) {
97846       {
97847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97848       };
97849     } catch (std::exception& e) {
97850       {
97851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97852       };
97853     } catch (Dali::DaliException e) {
97854       {
97855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97856       };
97857     } catch (...) {
97858       {
97859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97860       };
97861     }
97862   }
97863
97864   jresult = result;
97865   return jresult;
97866 }
97867
97868
97869 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
97870   float jresult ;
97871   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97872   float arg2 ;
97873   float arg3 ;
97874   float arg4 ;
97875   float arg5 ;
97876   Dali::Toolkit::ClampState *arg6 = 0 ;
97877   float result;
97878
97879   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97880   arg2 = (float)jarg2;
97881   arg3 = (float)jarg3;
97882   arg4 = (float)jarg4;
97883   arg5 = (float)jarg5;
97884   arg6 = (Dali::Toolkit::ClampState *)jarg6;
97885   if (!arg6) {
97886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
97887     return 0;
97888   }
97889   {
97890     try {
97891       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
97892     } catch (std::out_of_range& e) {
97893       {
97894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97895       };
97896     } catch (std::exception& e) {
97897       {
97898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97899       };
97900     } catch (Dali::DaliException e) {
97901       {
97902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97903       };
97904     } catch (...) {
97905       {
97906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97907       };
97908     }
97909   }
97910
97911   jresult = result;
97912   return jresult;
97913 }
97914
97915
97916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
97917   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97918
97919   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97920   {
97921     try {
97922       (*arg1)->Reference();
97923     } catch (std::out_of_range& e) {
97924       {
97925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97926       };
97927     } catch (std::exception& e) {
97928       {
97929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97930       };
97931     } catch (Dali::DaliException e) {
97932       {
97933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97934       };
97935     } catch (...) {
97936       {
97937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97938       };
97939     }
97940   }
97941
97942 }
97943
97944
97945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
97946   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97947
97948   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97949   {
97950     try {
97951       (*arg1)->Unreference();
97952     } catch (std::out_of_range& e) {
97953       {
97954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97955       };
97956     } catch (std::exception& e) {
97957       {
97958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97959       };
97960     } catch (Dali::DaliException e) {
97961       {
97962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97963       };
97964     } catch (...) {
97965       {
97966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97967       };
97968     }
97969   }
97970
97971 }
97972
97973
97974 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
97975   int jresult ;
97976   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
97977   int result;
97978
97979   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
97980   {
97981     try {
97982       result = (int)(*arg1)->ReferenceCount();
97983     } catch (std::out_of_range& e) {
97984       {
97985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97986       };
97987     } catch (std::exception& e) {
97988       {
97989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97990       };
97991     } catch (Dali::DaliException e) {
97992       {
97993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97994       };
97995     } catch (...) {
97996       {
97997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97998       };
97999     }
98000   }
98001
98002   jresult = result;
98003   return jresult;
98004 }
98005
98006
98007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
98008   unsigned int jresult ;
98009   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98010   bool result;
98011
98012   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98013   {
98014     try {
98015       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98016     } catch (std::out_of_range& e) {
98017       {
98018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98019       };
98020     } catch (std::exception& e) {
98021       {
98022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98023       };
98024     } catch (Dali::DaliException e) {
98025       {
98026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98027       };
98028     } catch (...) {
98029       {
98030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98031       };
98032     }
98033   }
98034
98035   jresult = result;
98036   return jresult;
98037 }
98038
98039
98040 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
98041   unsigned long jresult ;
98042   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98043   std::size_t result;
98044
98045   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98046   {
98047     try {
98048       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
98049     } catch (std::out_of_range& e) {
98050       {
98051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98052       };
98053     } catch (std::exception& e) {
98054       {
98055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98056       };
98057     } catch (Dali::DaliException e) {
98058       {
98059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98060       };
98061     } catch (...) {
98062       {
98063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98064       };
98065     }
98066   }
98067
98068   jresult = (unsigned long)result;
98069   return jresult;
98070 }
98071
98072
98073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
98074   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98075   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98076
98077   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98078   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98079   {
98080     try {
98081       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
98082     } catch (std::out_of_range& e) {
98083       {
98084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98085       };
98086     } catch (std::exception& e) {
98087       {
98088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98089       };
98090     } catch (Dali::DaliException e) {
98091       {
98092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98093       };
98094     } catch (...) {
98095       {
98096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98097       };
98098     }
98099   }
98100
98101 }
98102
98103
98104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
98105   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98106   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
98107
98108   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98109   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
98110   {
98111     try {
98112       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
98113     } catch (std::out_of_range& e) {
98114       {
98115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98116       };
98117     } catch (std::exception& e) {
98118       {
98119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98120       };
98121     } catch (Dali::DaliException e) {
98122       {
98123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98124       };
98125     } catch (...) {
98126       {
98127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98128       };
98129     }
98130   }
98131
98132 }
98133
98134
98135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
98136   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98137   Dali::Toolkit::Control arg2 ;
98138   Dali::Toolkit::Control *argp2 ;
98139
98140   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98141   argp2 = (Dali::Toolkit::Control *)jarg2;
98142   if (!argp2) {
98143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
98144     return ;
98145   }
98146   arg2 = *argp2;
98147   {
98148     try {
98149       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
98150     } catch (std::out_of_range& e) {
98151       {
98152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98153       };
98154     } catch (std::exception& e) {
98155       {
98156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98157       };
98158     } catch (Dali::DaliException e) {
98159       {
98160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98161       };
98162     } catch (...) {
98163       {
98164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98165       };
98166     }
98167   }
98168
98169 }
98170
98171
98172 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
98173   void * jresult ;
98174   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
98175
98176   {
98177     try {
98178       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
98179     } catch (std::out_of_range& e) {
98180       {
98181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98182       };
98183     } catch (std::exception& e) {
98184       {
98185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98186       };
98187     } catch (Dali::DaliException e) {
98188       {
98189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98190       };
98191     } catch (...) {
98192       {
98193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98194       };
98195     }
98196   }
98197
98198   jresult = (void *)result;
98199   return jresult;
98200 }
98201
98202
98203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
98204   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
98205
98206   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
98207   {
98208     try {
98209       delete arg1;
98210     } catch (std::out_of_range& e) {
98211       {
98212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98213       };
98214     } catch (std::exception& e) {
98215       {
98216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98217       };
98218     } catch (Dali::DaliException e) {
98219       {
98220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98221       };
98222     } catch (...) {
98223       {
98224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98225       };
98226     }
98227   }
98228
98229 }
98230
98231 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
98232   Dali::RefObject *result = NULL;
98233
98234   if (arg1)
98235   {
98236     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
98237   }
98238   return result;
98239 }
98240
98241 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
98242     return (Dali::RefObject *)jarg1;
98243 }
98244
98245 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
98246     return (Dali::SignalObserver *)jarg1;
98247 }
98248
98249 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
98250     return (Dali::ConnectionTrackerInterface *)jarg1;
98251 }
98252
98253 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
98254     return (Dali::BaseHandle *)jarg1;
98255 }
98256
98257 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
98258     return (Dali::BaseHandle *)jarg1;
98259 }
98260
98261 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
98262     return (Dali::BaseHandle *)jarg1;
98263 }
98264
98265 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
98266     return (Dali::BaseHandle *)jarg1;
98267 }
98268
98269 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
98270     return (Dali::BaseHandle *)jarg1;
98271 }
98272
98273 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
98274     return (Dali::BaseHandle *)jarg1;
98275 }
98276
98277 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Image_SWIGUpcast(Dali::Image *jarg1) {
98278     return (Dali::BaseHandle *)jarg1;
98279 }
98280
98281 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
98282     return (Dali::BaseHandle *)jarg1;
98283 }
98284
98285 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
98286     return (Dali::BaseHandle *)jarg1;
98287 }
98288
98289 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
98290     return (Dali::BaseHandle *)jarg1;
98291 }
98292
98293 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
98294     return (Dali::BaseHandle *)jarg1;
98295 }
98296
98297 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
98298     return (Dali::BaseHandle *)jarg1;
98299 }
98300
98301 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
98302     return (Dali::BaseHandle *)jarg1;
98303 }
98304
98305 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
98306     return (Dali::Handle *)jarg1;
98307 }
98308
98309 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
98310     return (Dali::Handle *)jarg1;
98311 }
98312
98313 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
98314     return (Dali::BaseHandle *)jarg1;
98315 }
98316
98317 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
98318     return (Dali::BaseHandle *)jarg1;
98319 }
98320
98321 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
98322     return (Dali::Handle *)jarg1;
98323 }
98324
98325 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
98326     return (Dali::BaseHandle *)jarg1;
98327 }
98328
98329 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
98330     return (Dali::Handle *)jarg1;
98331 }
98332
98333 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
98334     return (Dali::GestureDetector *)jarg1;
98335 }
98336
98337 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
98338     return (Dali::Gesture *)jarg1;
98339 }
98340
98341 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
98342     return (Dali::Handle *)jarg1;
98343 }
98344
98345 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
98346     return (Dali::Actor *)jarg1;
98347 }
98348
98349 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
98350     return (Dali::BaseHandle *)jarg1;
98351 }
98352
98353 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
98354     return (Dali::RefObject *)jarg1;
98355 }
98356
98357 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
98358     return (Dali::Actor *)jarg1;
98359 }
98360
98361 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
98362     return (Dali::GestureDetector *)jarg1;
98363 }
98364
98365 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
98366     return (Dali::Gesture *)jarg1;
98367 }
98368
98369 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
98370     return (Dali::GestureDetector *)jarg1;
98371 }
98372
98373 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
98374     return (Dali::Gesture *)jarg1;
98375 }
98376
98377 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
98378     return (Dali::GestureDetector *)jarg1;
98379 }
98380
98381 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
98382     return (Dali::Gesture *)jarg1;
98383 }
98384
98385 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
98386     return (Dali::BaseHandle *)jarg1;
98387 }
98388
98389 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
98390     return (Dali::Handle *)jarg1;
98391 }
98392
98393 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
98394     return (Dali::Handle *)jarg1;
98395 }
98396
98397 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
98398     return (Dali::Handle *)jarg1;
98399 }
98400
98401 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_BufferImage_SWIGUpcast(Dali::BufferImage *jarg1) {
98402     return (Dali::Image *)jarg1;
98403 }
98404
98405 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_NativeImage_SWIGUpcast(Dali::NativeImage *jarg1) {
98406     return (Dali::Image *)jarg1;
98407 }
98408
98409 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
98410     return (Dali::RefObject *)jarg1;
98411 }
98412
98413 SWIGEXPORT Dali::Image * SWIGSTDCALL CSharp_Dali_ResourceImage_SWIGUpcast(Dali::ResourceImage *jarg1) {
98414     return (Dali::Image *)jarg1;
98415 }
98416
98417 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
98418     return (Dali::Actor *)jarg1;
98419 }
98420
98421 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
98422     return (Dali::BaseHandle *)jarg1;
98423 }
98424
98425 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
98426     return (Dali::BaseHandle *)jarg1;
98427 }
98428
98429 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
98430     return (Dali::BaseHandle *)jarg1;
98431 }
98432
98433 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
98434     return (Dali::CustomActorImpl *)jarg1;
98435 }
98436
98437 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
98438     return (Dali::CustomActor *)jarg1;
98439 }
98440
98441 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
98442     return (Dali::BaseHandle *)jarg1;
98443 }
98444
98445 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
98446     return (Dali::Toolkit::Control *)jarg1;
98447 }
98448
98449 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
98450     return (Dali::Toolkit::Control *)jarg1;
98451 }
98452
98453 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
98454     return (Dali::Toolkit::Button *)jarg1;
98455 }
98456
98457 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
98458     return (Dali::Toolkit::Button *)jarg1;
98459 }
98460
98461 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
98462     return (Dali::Toolkit::Button *)jarg1;
98463 }
98464
98465 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
98466     return (Dali::Toolkit::Control *)jarg1;
98467 }
98468
98469 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
98470     return (Dali::Toolkit::Control *)jarg1;
98471 }
98472
98473 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
98474     return (Dali::Toolkit::Control *)jarg1;
98475 }
98476
98477 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
98478     return (Dali::Toolkit::Control *)jarg1;
98479 }
98480
98481 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
98482     return (Dali::Toolkit::Control *)jarg1;
98483 }
98484
98485 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
98486     return (Dali::RefObject *)jarg1;
98487 }
98488
98489 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
98490     return (Dali::Toolkit::Scrollable *)jarg1;
98491 }
98492
98493 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
98494     return (Dali::BaseHandle *)jarg1;
98495 }
98496
98497 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
98498     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
98499 }
98500
98501 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
98502     return (Dali::RefObject *)jarg1;
98503 }
98504
98505 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
98506     return (Dali::Toolkit::Ruler *)jarg1;
98507 }
98508
98509 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
98510     return (Dali::Toolkit::Ruler *)jarg1;
98511 }
98512
98513 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
98514     return (Dali::Toolkit::Scrollable *)jarg1;
98515 }
98516
98517 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
98518     return (Dali::Toolkit::Control *)jarg1;
98519 }
98520
98521
98522 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
98523     return (Dali::Toolkit::Control *)jarg1;
98524 }
98525
98526 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
98527     return (Dali::BaseHandle *)jarg1;
98528 }
98529
98530 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
98531     return (Dali::BaseHandle *)jarg1;
98532 }
98533
98534 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
98535     return (Dali::Toolkit::Control *)jarg1;
98536 }
98537
98538 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
98539     return (Dali::Toolkit::Control *)jarg1;
98540 }
98541
98542 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
98543     return (Dali::Toolkit::Control *)jarg1;
98544 }
98545
98546 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
98547     return (Dali::Toolkit::Control *)jarg1;
98548 }
98549
98550 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
98551     return (Dali::Toolkit::Control *)jarg1;
98552 }
98553
98554 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
98555     return (Dali::Toolkit::Control *)jarg1;
98556 }
98557
98558 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
98559     return (Dali::Toolkit::PageTurnView *)jarg1;
98560 }
98561
98562 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
98563     return (Dali::Toolkit::PageTurnView *)jarg1;
98564 }
98565
98566 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
98567     return (Dali::Toolkit::Button *)jarg1;
98568 }
98569
98570 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
98571     return (Dali::BaseHandle *)jarg1;
98572 }
98573
98574 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
98575     return (Dali::BaseHandle *)jarg1;
98576 }
98577
98578 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
98579     return (Dali::BaseHandle *)jarg1;
98580 }
98581
98582 /*
98583  * Widget binding
98584  */
98585 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
98586     return (Dali::BaseHandle *)jarg1;
98587 }
98588
98589 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
98590     return (Dali::BaseObject *)jarg1;
98591 }
98592
98593 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
98594   void * jresult ;
98595   Dali::Widget result;
98596
98597   {
98598     try {
98599       result = Dali::Widget::New();
98600     } catch (std::out_of_range& e) {
98601       {
98602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98603       };
98604     } catch (std::exception& e) {
98605       {
98606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98607       };
98608     } catch (...) {
98609       {
98610         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98611       };
98612     }
98613   }
98614   jresult = new Dali::Widget((const Dali::Widget &)result);
98615   return jresult;
98616 }
98617
98618
98619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
98620   void * jresult ;
98621   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
98622   Dali::Widget result;
98623
98624   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98625
98626   if (!arg1) {
98627     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
98628     return 0;
98629   }
98630   {
98631     try {
98632       jresult = new Dali::Widget(arg1);
98633     } catch (std::out_of_range& e) {
98634       {
98635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98636       };
98637     } catch (std::exception& e) {
98638       {
98639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98640       };
98641     } catch (...) {
98642       {
98643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98644       };
98645     }
98646   }
98647   return jresult;
98648 }
98649
98650
98651 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
98652   void * jresult ;
98653   Dali::Widget *result = 0 ;
98654
98655   {
98656     try {
98657       result = (Dali::Widget *)new Dali::Widget();
98658     } catch (std::out_of_range& e) {
98659       {
98660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98661       };
98662     } catch (std::exception& e) {
98663       {
98664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98665       };
98666     } catch (...) {
98667       {
98668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98669       };
98670     }
98671   }
98672   jresult = (void *)result;
98673   return jresult;
98674 }
98675
98676
98677 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
98678   void * jresult ;
98679   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
98680   Dali::Widget *arg2 = 0 ;
98681   Dali::Widget *result = 0 ;
98682
98683   arg1 = (Dali::Widget *)jarg1;
98684   arg2 = (Dali::Widget *)jarg2;
98685   if (!arg2) {
98686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
98687     return 0;
98688   }
98689   {
98690     try {
98691       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
98692     } catch (std::out_of_range& e) {
98693       {
98694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98695       };
98696     } catch (std::exception& e) {
98697       {
98698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98699       };
98700     } catch (...) {
98701       {
98702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98703       };
98704     }
98705   }
98706   jresult = (void *)result;
98707   return jresult;
98708 }
98709
98710
98711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
98712   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
98713
98714   arg1 = (Dali::Widget *)jarg1;
98715   {
98716     try {
98717       delete arg1;
98718     } catch (std::out_of_range& e) {
98719       {
98720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98721       };
98722     } catch (std::exception& e) {
98723       {
98724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98725       };
98726     } catch (...) {
98727       {
98728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98729       };
98730     }
98731   }
98732 }
98733
98734
98735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
98736   void * jresult ;
98737   SwigDirector_WidgetImpl* result;
98738   {
98739     try {
98740       result = new SwigDirector_WidgetImpl();
98741     } catch (std::out_of_range& e) {
98742       {
98743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98744       };
98745     } catch (std::exception& e) {
98746       {
98747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98748       };
98749     } catch (...) {
98750       {
98751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98752       };
98753     }
98754   }
98755   jresult = result;
98756   return jresult;
98757 }
98758
98759
98760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
98761   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98762   std::string *arg2 = 0 ;
98763   Dali::Window arg3 ;
98764   Dali::Window *argp3 ;
98765
98766   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98767   if (!jarg2) {
98768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98769     return ;
98770   }
98771   std::string arg2_str(jarg2);
98772   arg2 = &arg2_str;
98773   argp3 = (Dali::Window *)jarg3;
98774   if (!argp3) {
98775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
98776     return ;
98777   }
98778   arg3 = *argp3;
98779   {
98780     try {
98781       (arg1)->OnCreate((std::string const &)*arg2,arg3);
98782     } catch (std::out_of_range& e) {
98783       {
98784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98785       };
98786     } catch (std::exception& e) {
98787       {
98788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98789       };
98790     } catch (...) {
98791       {
98792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98793       };
98794     }
98795   }
98796 }
98797
98798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
98799   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98800   std::string *arg2 = 0 ;
98801   Dali::Window arg3 ;
98802   Dali::Window *argp3 ;
98803
98804   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98805   if (!jarg2) {
98806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98807     return ;
98808   }
98809   std::string arg2_str(jarg2);
98810   arg2 = &arg2_str;
98811   argp3 = (Dali::Window *)jarg3;
98812   if (!argp3) {
98813     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
98814     return ;
98815   }
98816   arg3 = *argp3;
98817   {
98818     try {
98819       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
98820     } catch (std::out_of_range& e) {
98821       {
98822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98823       };
98824     } catch (std::exception& e) {
98825       {
98826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98827       };
98828     } catch (...) {
98829       {
98830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98831       };
98832     }
98833   }
98834 }
98835
98836
98837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
98838   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98839   std::string *arg2 = 0 ;
98840   Dali::Widget::Termination arg3 ;
98841
98842   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98843   if (!jarg2) {
98844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98845     return ;
98846   }
98847   std::string arg2_str(jarg2);
98848   arg2 = &arg2_str;
98849   arg3 = (Dali::Widget::Termination)jarg3;
98850   {
98851     try {
98852       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
98853     } catch (std::out_of_range& e) {
98854       {
98855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98856       };
98857     } catch (std::exception& e) {
98858       {
98859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98860       };
98861     } catch (...) {
98862       {
98863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98864       };
98865     }
98866   }
98867 }
98868
98869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
98870   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98871   std::string *arg2 = 0 ;
98872   Dali::Widget::Termination arg3 ;
98873
98874   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98875   if (!jarg2) {
98876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98877     return ;
98878   }
98879   std::string arg2_str(jarg2);
98880   arg2 = &arg2_str;
98881   arg3 = (Dali::Widget::Termination)jarg3;
98882   {
98883     try {
98884       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
98885     } catch (std::out_of_range& e) {
98886       {
98887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98888       };
98889     } catch (std::exception& e) {
98890       {
98891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98892       };
98893     } catch (...) {
98894       {
98895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98896       };
98897     }
98898   }
98899 }
98900
98901
98902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
98903   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98904
98905   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98906   {
98907     try {
98908       (arg1)->OnPause();
98909     } catch (std::out_of_range& e) {
98910       {
98911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98912       };
98913     } catch (std::exception& e) {
98914       {
98915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98916       };
98917     } catch (...) {
98918       {
98919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98920       };
98921     }
98922   }
98923 }
98924
98925 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
98926   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98927
98928   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98929   {
98930     try {
98931       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
98932     } catch (std::out_of_range& e) {
98933       {
98934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98935       };
98936     } catch (std::exception& e) {
98937       {
98938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98939       };
98940     } catch (...) {
98941       {
98942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98943       };
98944     }
98945   }
98946 }
98947
98948
98949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
98950   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98951
98952   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98953   {
98954     try {
98955       (arg1)->OnResume();
98956     } catch (std::out_of_range& e) {
98957       {
98958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98959       };
98960     } catch (std::exception& e) {
98961       {
98962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98963       };
98964     } catch (...) {
98965       {
98966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98967       };
98968     }
98969   }
98970 }
98971
98972
98973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
98974   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98975
98976   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
98977   {
98978     try {
98979       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
98980     } catch (std::out_of_range& e) {
98981       {
98982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98983       };
98984     } catch (std::exception& e) {
98985       {
98986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98987       };
98988     } catch (...) {
98989       {
98990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98991       };
98992     }
98993   }
98994 }
98995
98996
98997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
98998   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
98999   Dali::Window arg2 ;
99000   Dali::Window *argp2 ;
99001
99002   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99003   argp2 = (Dali::Window *)jarg2;
99004   if (!argp2) {
99005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99006     return ;
99007   }
99008   arg2 = *argp2;
99009   {
99010     try {
99011       (arg1)->OnResize(arg2);
99012     } catch (std::out_of_range& e) {
99013       {
99014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99015       };
99016     } catch (std::exception& e) {
99017       {
99018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99019       };
99020     } catch (...) {
99021       {
99022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99023       };
99024     }
99025   }
99026 }
99027
99028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
99029   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99030   Dali::Window arg2 ;
99031   Dali::Window *argp2 ;
99032
99033   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99034   argp2 = (Dali::Window *)jarg2;
99035   if (!argp2) {
99036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
99037     return ;
99038   }
99039   arg2 = *argp2;
99040   {
99041     try {
99042       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
99043     } catch (std::out_of_range& e) {
99044       {
99045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99046       };
99047     } catch (std::exception& e) {
99048       {
99049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99050       };
99051     } catch (...) {
99052       {
99053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99054       };
99055     }
99056   }
99057 }
99058
99059
99060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
99061   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99062   std::string *arg2 = 0 ;
99063   int arg3 ;
99064
99065   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99066   if (!jarg2) {
99067     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99068     return ;
99069   }
99070   std::string arg2_str(jarg2);
99071   arg2 = &arg2_str;
99072   arg3 = (int)jarg3;
99073   {
99074     try {
99075       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
99076     } catch (std::out_of_range& e) {
99077       {
99078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99079       };
99080     } catch (std::exception& e) {
99081       {
99082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99083       };
99084     } catch (...) {
99085       {
99086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99087       };
99088     }
99089   }
99090 }
99091
99092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
99093   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99094   std::string *arg2 = 0 ;
99095   int arg3 ;
99096
99097   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99098   if (!jarg2) {
99099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99100     return ;
99101   }
99102   std::string arg2_str(jarg2);
99103   arg2 = &arg2_str;
99104   arg3 = (int)jarg3;
99105   {
99106     try {
99107       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
99108     } catch (std::out_of_range& e) {
99109       {
99110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99111       };
99112     } catch (std::exception& e) {
99113       {
99114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99115       };
99116     } catch (...) {
99117       {
99118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99119       };
99120     }
99121   }
99122 }
99123
99124
99125 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
99126   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99127   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
99128   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
99129
99130   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99131   arg2 = (Dali::SlotObserver *)jarg2;
99132   arg3 = (Dali::CallbackBase *)jarg3;
99133   {
99134     try {
99135       (arg1)->SignalConnected(arg2,arg3);
99136     } catch (std::out_of_range& e) {
99137       {
99138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99139       };
99140     } catch (std::exception& e) {
99141       {
99142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99143       };
99144     } catch (...) {
99145       {
99146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99147       };
99148     }
99149   }
99150 }
99151
99152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
99153   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99154   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
99155   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
99156
99157   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99158   arg2 = (Dali::SlotObserver *)jarg2;
99159   arg3 = (Dali::CallbackBase *)jarg3;
99160   {
99161     try {
99162       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
99163     } catch (std::out_of_range& e) {
99164       {
99165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99166       };
99167     } catch (std::exception& e) {
99168       {
99169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99170       };
99171     } catch (...) {
99172       {
99173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99174       };
99175     }
99176   }
99177 }
99178
99179
99180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
99181   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99182   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
99183   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
99184
99185   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99186   arg2 = (Dali::SlotObserver *)jarg2;
99187   arg3 = (Dali::CallbackBase *)jarg3;
99188   {
99189     try {
99190       (arg1)->SignalDisconnected(arg2,arg3);
99191     } catch (std::out_of_range& e) {
99192       {
99193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99194       };
99195     } catch (std::exception& e) {
99196       {
99197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99198       };
99199     } catch (...) {
99200       {
99201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99202       };
99203     }
99204   }
99205 }
99206
99207 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
99208   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99209   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
99210   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
99211
99212   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99213   arg2 = (Dali::SlotObserver *)jarg2;
99214   arg3 = (Dali::CallbackBase *)jarg3;
99215   {
99216     try {
99217       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
99218     } catch (std::out_of_range& e) {
99219       {
99220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99221       };
99222     } catch (std::exception& e) {
99223       {
99224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99225       };
99226     } catch (...) {
99227       {
99228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99229       };
99230     }
99231   }
99232 }
99233
99234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
99235   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99236   std::string *arg2 = 0 ;
99237
99238   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99239   if (!jarg2) {
99240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99241     return ;
99242   }
99243   std::string arg2_str(jarg2);
99244   arg2 = &arg2_str;
99245   {
99246     try {
99247       (arg1)->SetContentInfo((std::string const &)*arg2);
99248     } catch (std::out_of_range& e) {
99249       {
99250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99251       };
99252     } catch (std::exception& e) {
99253       {
99254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99255       };
99256     } catch (...) {
99257       {
99258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99259       };
99260     }
99261   }
99262 }
99263
99264
99265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
99266   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
99267   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
99268
99269   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
99270   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
99271   {
99272     try {
99273       (arg1)->SetImpl(arg2);
99274     } catch (std::out_of_range& e) {
99275       {
99276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99277       };
99278     } catch (std::exception& e) {
99279       {
99280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99281       };
99282     } catch (...) {
99283       {
99284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99285       };
99286     }
99287   }
99288 }
99289
99290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_director_connect(void *objarg, SwigDirector_WidgetImpl::SWIG_Callback0_t callback0, SwigDirector_WidgetImpl::SWIG_Callback1_t callback1, SwigDirector_WidgetImpl::SWIG_Callback2_t callback2, SwigDirector_WidgetImpl::SWIG_Callback3_t callback3, SwigDirector_WidgetImpl::SWIG_Callback4_t callback4, SwigDirector_WidgetImpl::SWIG_Callback5_t callback5, SwigDirector_WidgetImpl::SWIG_Callback6_t callback6, SwigDirector_WidgetImpl::SWIG_Callback7_t callback7) {
99291
99292   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
99293   if (director) {
99294     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
99295   }
99296 }
99297
99298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
99299   void * jresult ;
99300   Dali::Widget *arg1 = 0 ;
99301   SwigDirector_WidgetImpl *result = 0 ;
99302
99303   arg1 = (Dali::Widget *)jarg1;
99304   if (!arg1) {
99305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
99306     return 0;
99307   }
99308   {
99309     try {
99310       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
99311     } catch (std::out_of_range& e) {
99312       {
99313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99314       };
99315     } catch (std::exception& e) {
99316       {
99317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99318       };
99319     } catch (...) {
99320       {
99321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99322       };
99323     }
99324   }
99325
99326   jresult = (void *)result;
99327   return jresult;
99328 }
99329
99330
99331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
99332   void * jresult ;
99333   int *arg1 = (int *) 0 ;
99334   char ***arg2 ;
99335   std::string *arg3 = 0 ;
99336   Dali::WidgetApplication result;
99337   {
99338     int index = 0;
99339     int length = 0;
99340     char *retPtr;
99341     char *nextPtr;
99342     argWidgetC = jarg1;
99343     argWidgetV = new char*[jarg1 + 1];
99344
99345     retPtr = strtok_r( jarg2, " ", &nextPtr);
99346     if( retPtr )
99347     {
99348       length = strlen(retPtr);
99349     }
99350     argWidgetV[index] = new char[length + 1];
99351     if( retPtr )
99352     {
99353       strncpy(argWidgetV[index], retPtr, length);
99354     }
99355     argWidgetV[index][length] = '\0';
99356     index++;
99357
99358     while (index < jarg1)
99359     {
99360       length = 0;
99361       retPtr = strtok_r(NULL, " ", &nextPtr);
99362       if( retPtr )
99363       {
99364         length = strlen(retPtr);
99365       }
99366       argWidgetV[index] = new char[length + 1];
99367       if( retPtr )
99368       {
99369         strncpy(argWidgetV[index], retPtr, length);
99370       }
99371       argWidgetV[index][length] = '\0';
99372       index++;
99373     }
99374
99375     argWidgetV[jarg1] = NULL;
99376     argWidgetC = jarg1;
99377
99378     arg1 = &argWidgetC;
99379     arg2 = &argWidgetV;
99380   }
99381
99382   if (!jarg3) {
99383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99384     return 0;
99385   }
99386   std::string arg3_str(jarg3);
99387   arg3 = &arg3_str;
99388   {
99389     try {
99390       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
99391     } catch (std::out_of_range& e) {
99392       {
99393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99394       };
99395     } catch (std::exception& e) {
99396       {
99397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99398       };
99399     } catch (...) {
99400       {
99401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99402       };
99403     }
99404   }
99405   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
99406
99407   return jresult;
99408 }
99409
99410
99411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
99412   void * jresult ;
99413   Dali::WidgetApplication *result = 0 ;
99414
99415   {
99416     try {
99417       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
99418     } catch (std::out_of_range& e) {
99419       {
99420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99421       };
99422     } catch (std::exception& e) {
99423       {
99424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99425       };
99426     } catch (...) {
99427       {
99428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99429       };
99430     }
99431   }
99432   jresult = (void *)result;
99433   return jresult;
99434 }
99435
99436
99437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
99438   void * jresult ;
99439   Dali::WidgetApplication *arg1 = 0 ;
99440   Dali::WidgetApplication *result = 0 ;
99441
99442   arg1 = (Dali::WidgetApplication *)jarg1;
99443   if (!arg1) {
99444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
99445     return 0;
99446   }
99447   {
99448     try {
99449       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
99450     } catch (std::out_of_range& e) {
99451       {
99452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99453       };
99454     } catch (std::exception& e) {
99455       {
99456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99457       };
99458     } catch (...) {
99459       {
99460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99461       };
99462     }
99463   }
99464   jresult = (void *)result;
99465   return jresult;
99466 }
99467
99468
99469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
99470   void * jresult ;
99471   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
99472   Dali::WidgetApplication *arg2 = 0 ;
99473   Dali::WidgetApplication *result = 0 ;
99474
99475   arg1 = (Dali::WidgetApplication *)jarg1;
99476   arg2 = (Dali::WidgetApplication *)jarg2;
99477   if (!arg2) {
99478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
99479     return 0;
99480   }
99481   {
99482     try {
99483       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
99484     } catch (std::out_of_range& e) {
99485       {
99486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99487       };
99488     } catch (std::exception& e) {
99489       {
99490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99491       };
99492     } catch (...) {
99493       {
99494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99495       };
99496     }
99497   }
99498   jresult = (void *)result;
99499   return jresult;
99500 }
99501
99502
99503 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
99504   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
99505
99506   arg1 = (Dali::WidgetApplication *)jarg1;
99507   {
99508     try {
99509       delete arg1;
99510       if( argWidgetV )
99511       {
99512         // free string data
99513         for( int i=0; i < argWidgetC+1; i++)
99514         {
99515           delete [] argWidgetV[i];
99516         }
99517         delete [] argWidgetV;
99518       }
99519     } catch (std::out_of_range& e) {
99520       {
99521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99522       };
99523     } catch (std::exception& e) {
99524       {
99525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99526       };
99527     } catch (...) {
99528       {
99529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99530       };
99531     }
99532   }
99533 }
99534
99535
99536 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
99537 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
99538
99539 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
99540 {
99541   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
99542   return *widget;
99543 }
99544
99545 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
99546   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
99547   std::string *arg2 = 0 ;
99548
99549   arg1 = (Dali::WidgetApplication *)jarg1;
99550   if (!jarg2) {
99551     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
99552     return ;
99553   }
99554   std::string arg2_str(*jarg2);
99555   arg2 = &arg2_str;
99556
99557   if(!_CSharpCreateWidgetFunction)
99558   {
99559     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
99560   }
99561
99562   {
99563     try {
99564       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
99565     } catch (std::out_of_range& e) {
99566       {
99567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99568       };
99569     } catch (std::exception& e) {
99570       {
99571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99572       };
99573     } catch (...) {
99574       {
99575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99576       };
99577     }
99578   }
99579
99580   //Typemap argout in c++ file.
99581   //This will convert c++ string to c# string
99582   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
99583 }
99584
99585
99586 //for PixelBuffer and ImageLoading
99587
99588 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
99589     return (Dali::BaseHandle *)jarg1;
99590 }
99591
99592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
99593   void * jresult ;
99594   unsigned int arg1 ;
99595   unsigned int arg2 ;
99596   Dali::Pixel::Format arg3 ;
99597   Dali::Devel::PixelBuffer result;
99598
99599   arg1 = (unsigned int)jarg1;
99600   arg2 = (unsigned int)jarg2;
99601   arg3 = (Dali::Pixel::Format)jarg3;
99602   {
99603     try {
99604       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
99605     } catch (std::out_of_range& e) {
99606       {
99607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99608       };
99609     } catch (std::exception& e) {
99610       {
99611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99612       };
99613     } catch (...) {
99614       {
99615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99616       };
99617     }
99618   }
99619   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
99620   return jresult;
99621 }
99622
99623
99624 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
99625   void * jresult ;
99626   Dali::Devel::PixelBuffer *result = 0 ;
99627
99628   {
99629     try {
99630       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
99631     } catch (std::out_of_range& e) {
99632       {
99633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99634       };
99635     } catch (std::exception& e) {
99636       {
99637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99638       };
99639     } catch (...) {
99640       {
99641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99642       };
99643     }
99644   }
99645   jresult = (void *)result;
99646   return jresult;
99647 }
99648
99649
99650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
99651   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99652
99653   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99654   {
99655     try {
99656       delete arg1;
99657     } catch (std::out_of_range& e) {
99658       {
99659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99660       };
99661     } catch (std::exception& e) {
99662       {
99663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99664       };
99665     } catch (...) {
99666       {
99667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99668       };
99669     }
99670   }
99671 }
99672
99673
99674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
99675   void * jresult ;
99676   Dali::Devel::PixelBuffer *arg1 = 0 ;
99677   Dali::Devel::PixelBuffer *result = 0 ;
99678
99679   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99680   if (!arg1) {
99681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
99682     return 0;
99683   }
99684   {
99685     try {
99686       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
99687     } catch (std::out_of_range& e) {
99688       {
99689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99690       };
99691     } catch (std::exception& e) {
99692       {
99693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99694       };
99695     } catch (...) {
99696       {
99697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99698       };
99699     }
99700   }
99701   jresult = (void *)result;
99702   return jresult;
99703 }
99704
99705
99706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
99707   void * jresult ;
99708   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99709   Dali::Devel::PixelBuffer *arg2 = 0 ;
99710   Dali::Devel::PixelBuffer *result = 0 ;
99711
99712   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99713   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
99714   if (!arg2) {
99715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
99716     return 0;
99717   }
99718   {
99719     try {
99720       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
99721     } catch (std::out_of_range& e) {
99722       {
99723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99724       };
99725     } catch (std::exception& e) {
99726       {
99727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99728       };
99729     } catch (...) {
99730       {
99731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99732       };
99733     }
99734   }
99735   jresult = (void *)result;
99736   return jresult;
99737 }
99738
99739
99740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
99741   void * jresult ;
99742   Dali::Devel::PixelBuffer *arg1 = 0 ;
99743   Dali::PixelData result;
99744
99745   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99746   if (!arg1) {
99747     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
99748     return 0;
99749   }
99750   {
99751     try {
99752       result = Dali::Devel::PixelBuffer::Convert(*arg1);
99753     } catch (std::out_of_range& e) {
99754       {
99755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99756       };
99757     } catch (std::exception& e) {
99758       {
99759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99760       };
99761     } catch (...) {
99762       {
99763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99764       };
99765     }
99766   }
99767   jresult = new Dali::PixelData((const Dali::PixelData &)result);
99768   return jresult;
99769 }
99770
99771
99772 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
99773   void * jresult ;
99774   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99775   Dali::PixelData result;
99776
99777   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99778   {
99779     try {
99780       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
99781     } catch (std::out_of_range& e) {
99782       {
99783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99784       };
99785     } catch (std::exception& e) {
99786       {
99787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99788       };
99789     } catch (...) {
99790       {
99791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99792       };
99793     }
99794   }
99795   jresult = new Dali::PixelData((const Dali::PixelData &)result);
99796   return jresult;
99797 }
99798
99799
99800 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
99801   void * jresult ;
99802   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99803   unsigned char *result = 0 ;
99804
99805   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99806   {
99807     try {
99808       result = (unsigned char *)(arg1)->GetBuffer();
99809     } catch (std::out_of_range& e) {
99810       {
99811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99812       };
99813     } catch (std::exception& e) {
99814       {
99815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99816       };
99817     } catch (...) {
99818       {
99819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99820       };
99821     }
99822   }
99823   jresult = (void *)result;
99824   return jresult;
99825 }
99826
99827
99828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
99829   unsigned int jresult ;
99830   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99831   unsigned int result;
99832
99833   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99834   {
99835     try {
99836       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
99837     } catch (std::out_of_range& e) {
99838       {
99839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99840       };
99841     } catch (std::exception& e) {
99842       {
99843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99844       };
99845     } catch (...) {
99846       {
99847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99848       };
99849     }
99850   }
99851   jresult = result;
99852   return jresult;
99853 }
99854
99855
99856 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
99857   unsigned int jresult ;
99858   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99859   unsigned int result;
99860
99861   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99862   {
99863     try {
99864       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
99865     } catch (std::out_of_range& e) {
99866       {
99867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99868       };
99869     } catch (std::exception& e) {
99870       {
99871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99872       };
99873     } catch (...) {
99874       {
99875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99876       };
99877     }
99878   }
99879   jresult = result;
99880   return jresult;
99881 }
99882
99883
99884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
99885   int jresult ;
99886   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99887   Dali::Pixel::Format result;
99888
99889   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99890   {
99891     try {
99892       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
99893     } catch (std::out_of_range& e) {
99894       {
99895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99896       };
99897     } catch (std::exception& e) {
99898       {
99899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99900       };
99901     } catch (...) {
99902       {
99903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99904       };
99905     }
99906   }
99907   jresult = (int)result;
99908   return jresult;
99909 }
99910
99911
99912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
99913   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99914   Dali::Devel::PixelBuffer arg2 ;
99915   float arg3 ;
99916   bool arg4 ;
99917   Dali::Devel::PixelBuffer *argp2 ;
99918
99919   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99920   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
99921   if (!argp2) {
99922     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
99923     return ;
99924   }
99925   arg2 = *argp2;
99926   arg3 = (float)jarg3;
99927   arg4 = jarg4 ? true : false;
99928   {
99929     try {
99930       (arg1)->ApplyMask(arg2,arg3,arg4);
99931     } catch (std::out_of_range& e) {
99932       {
99933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99934       };
99935     } catch (std::exception& e) {
99936       {
99937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99938       };
99939     } catch (...) {
99940       {
99941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99942       };
99943     }
99944   }
99945 }
99946
99947
99948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
99949   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99950   Dali::Devel::PixelBuffer arg2 ;
99951   float arg3 ;
99952   Dali::Devel::PixelBuffer *argp2 ;
99953
99954   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99955   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
99956   if (!argp2) {
99957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
99958     return ;
99959   }
99960   arg2 = *argp2;
99961   arg3 = (float)jarg3;
99962   {
99963     try {
99964       (arg1)->ApplyMask(arg2,arg3);
99965     } catch (std::out_of_range& e) {
99966       {
99967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99968       };
99969     } catch (std::exception& e) {
99970       {
99971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99972       };
99973     } catch (...) {
99974       {
99975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99976       };
99977     }
99978   }
99979 }
99980
99981
99982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
99983   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
99984   Dali::Devel::PixelBuffer arg2 ;
99985   Dali::Devel::PixelBuffer *argp2 ;
99986
99987   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
99988   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
99989   if (!argp2) {
99990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
99991     return ;
99992   }
99993   arg2 = *argp2;
99994   {
99995     try {
99996       (arg1)->ApplyMask(arg2);
99997     } catch (std::out_of_range& e) {
99998       {
99999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100000       };
100001     } catch (std::exception& e) {
100002       {
100003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100004       };
100005     } catch (...) {
100006       {
100007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100008       };
100009     }
100010   }
100011 }
100012
100013
100014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
100015   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100016   float arg2 ;
100017
100018   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100019   arg2 = (float)jarg2;
100020   {
100021     try {
100022       (arg1)->ApplyGaussianBlur(arg2);
100023     } catch (std::out_of_range& e) {
100024       {
100025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100026       };
100027     } catch (std::exception& e) {
100028       {
100029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100030       };
100031     } catch (...) {
100032       {
100033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100034       };
100035     }
100036   }
100037 }
100038
100039
100040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
100041   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100042   uint16_t arg2 ;
100043   uint16_t arg3 ;
100044   uint16_t arg4 ;
100045   uint16_t arg5 ;
100046
100047   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100048   arg2 = (uint16_t)jarg2;
100049   arg3 = (uint16_t)jarg3;
100050   arg4 = (uint16_t)jarg4;
100051   arg5 = (uint16_t)jarg5;
100052   {
100053     try {
100054       (arg1)->Crop(arg2,arg3,arg4,arg5);
100055     } catch (std::out_of_range& e) {
100056       {
100057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100058       };
100059     } catch (std::exception& e) {
100060       {
100061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100062       };
100063     } catch (...) {
100064       {
100065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100066       };
100067     }
100068   }
100069 }
100070
100071
100072 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
100073   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100074   uint16_t arg2 ;
100075   uint16_t arg3 ;
100076
100077   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100078   arg2 = (uint16_t)jarg2;
100079   arg3 = (uint16_t)jarg3;
100080   {
100081     try {
100082       (arg1)->Resize(arg2,arg3);
100083     } catch (std::out_of_range& e) {
100084       {
100085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100086       };
100087     } catch (std::exception& e) {
100088       {
100089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100090       };
100091     } catch (...) {
100092       {
100093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100094       };
100095     }
100096   }
100097 }
100098
100099 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
100100   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
100101   Dali::Degree * arg2 ;
100102
100103   bool result = false;
100104
100105   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
100106   arg2 = (Dali::Degree *)jarg2;
100107   {
100108     try {
100109       result = (arg1)->Rotate(*arg2);
100110     } catch (std::out_of_range& e) {
100111       {
100112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
100113       };
100114     } catch (std::exception& e) {
100115       {
100116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
100117       };
100118     } catch (...) {
100119       {
100120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
100121       };
100122     }
100123   }
100124   return result;
100125 }
100126
100127
100128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
100129   void * jresult ;
100130   std::string *arg1 = 0 ;
100131   Dali::ImageDimensions arg2 ;
100132   Dali::FittingMode::Type arg3 ;
100133   Dali::SamplingMode::Type arg4 ;
100134   bool arg5 ;
100135   Dali::ImageDimensions *argp2 ;
100136   Dali::Devel::PixelBuffer result;
100137
100138   if (!jarg1) {
100139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100140     return 0;
100141   }
100142   std::string arg1_str(jarg1);
100143   arg1 = &arg1_str;
100144   argp2 = (Dali::ImageDimensions *)jarg2;
100145   if (!argp2) {
100146     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100147     return 0;
100148   }
100149   arg2 = *argp2;
100150   arg3 = (Dali::FittingMode::Type)jarg3;
100151   arg4 = (Dali::SamplingMode::Type)jarg4;
100152   arg5 = jarg5 ? true : false;
100153   {
100154     try {
100155       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
100156     } catch (std::out_of_range& e) {
100157       {
100158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100159       };
100160     } catch (std::exception& e) {
100161       {
100162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100163       };
100164     } catch (...) {
100165       {
100166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100167       };
100168     }
100169   }
100170   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100171
100172   return jresult;
100173 }
100174
100175
100176 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
100177   void * jresult ;
100178   std::string *arg1 = 0 ;
100179   Dali::ImageDimensions arg2 ;
100180   Dali::FittingMode::Type arg3 ;
100181   Dali::SamplingMode::Type arg4 ;
100182   Dali::ImageDimensions *argp2 ;
100183   Dali::Devel::PixelBuffer result;
100184
100185   if (!jarg1) {
100186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100187     return 0;
100188   }
100189   std::string arg1_str(jarg1);
100190   arg1 = &arg1_str;
100191   argp2 = (Dali::ImageDimensions *)jarg2;
100192   if (!argp2) {
100193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100194     return 0;
100195   }
100196   arg2 = *argp2;
100197   arg3 = (Dali::FittingMode::Type)jarg3;
100198   arg4 = (Dali::SamplingMode::Type)jarg4;
100199   {
100200     try {
100201       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
100202     } catch (std::out_of_range& e) {
100203       {
100204         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100205       };
100206     } catch (std::exception& e) {
100207       {
100208         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100209       };
100210     } catch (...) {
100211       {
100212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100213       };
100214     }
100215   }
100216   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100217
100218   return jresult;
100219 }
100220
100221
100222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
100223   void * jresult ;
100224   std::string *arg1 = 0 ;
100225   Dali::ImageDimensions arg2 ;
100226   Dali::FittingMode::Type arg3 ;
100227   Dali::ImageDimensions *argp2 ;
100228   Dali::Devel::PixelBuffer result;
100229
100230   if (!jarg1) {
100231     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100232     return 0;
100233   }
100234   std::string arg1_str(jarg1);
100235   arg1 = &arg1_str;
100236   argp2 = (Dali::ImageDimensions *)jarg2;
100237   if (!argp2) {
100238     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100239     return 0;
100240   }
100241   arg2 = *argp2;
100242   arg3 = (Dali::FittingMode::Type)jarg3;
100243   {
100244     try {
100245       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
100246     } catch (std::out_of_range& e) {
100247       {
100248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100249       };
100250     } catch (std::exception& e) {
100251       {
100252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100253       };
100254     } catch (...) {
100255       {
100256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100257       };
100258     }
100259   }
100260   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100261
100262   return jresult;
100263 }
100264
100265
100266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
100267   void * jresult ;
100268   std::string *arg1 = 0 ;
100269   Dali::ImageDimensions arg2 ;
100270   Dali::ImageDimensions *argp2 ;
100271   Dali::Devel::PixelBuffer result;
100272
100273   if (!jarg1) {
100274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100275     return 0;
100276   }
100277   std::string arg1_str(jarg1);
100278   arg1 = &arg1_str;
100279   argp2 = (Dali::ImageDimensions *)jarg2;
100280   if (!argp2) {
100281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100282     return 0;
100283   }
100284   arg2 = *argp2;
100285   {
100286     try {
100287       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
100288     } catch (std::out_of_range& e) {
100289       {
100290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100291       };
100292     } catch (std::exception& e) {
100293       {
100294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100295       };
100296     } catch (...) {
100297       {
100298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100299       };
100300     }
100301   }
100302   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100303
100304   return jresult;
100305 }
100306
100307
100308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
100309   void * jresult ;
100310   std::string *arg1 = 0 ;
100311   Dali::Devel::PixelBuffer result;
100312
100313   if (!jarg1) {
100314     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100315     return 0;
100316   }
100317   std::string arg1_str(jarg1);
100318   arg1 = &arg1_str;
100319   {
100320     try {
100321       result = Dali::LoadImageFromFile((std::string const &)*arg1);
100322     } catch (std::out_of_range& e) {
100323       {
100324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100325       };
100326     } catch (std::exception& e) {
100327       {
100328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100329       };
100330     } catch (...) {
100331       {
100332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100333       };
100334     }
100335   }
100336   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100337
100338   return jresult;
100339 }
100340
100341
100342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
100343   void * jresult ;
100344   std::string *arg1 = 0 ;
100345   Dali::ImageDimensions arg2 ;
100346   Dali::FittingMode::Type arg3 ;
100347   Dali::SamplingMode::Type arg4 ;
100348   bool arg5 ;
100349   Dali::ImageDimensions *argp2 ;
100350   Dali::ImageDimensions result;
100351
100352   if (!jarg1) {
100353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100354     return 0;
100355   }
100356   std::string arg1_str(jarg1);
100357   arg1 = &arg1_str;
100358   argp2 = (Dali::ImageDimensions *)jarg2;
100359   if (!argp2) {
100360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100361     return 0;
100362   }
100363   arg2 = *argp2;
100364   arg3 = (Dali::FittingMode::Type)jarg3;
100365   arg4 = (Dali::SamplingMode::Type)jarg4;
100366   arg5 = jarg5 ? true : false;
100367   {
100368     try {
100369       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
100370     } catch (std::out_of_range& e) {
100371       {
100372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100373       };
100374     } catch (std::exception& e) {
100375       {
100376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100377       };
100378     } catch (...) {
100379       {
100380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100381       };
100382     }
100383   }
100384   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
100385
100386   return jresult;
100387 }
100388
100389
100390 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
100391   void * jresult ;
100392   std::string *arg1 = 0 ;
100393   Dali::ImageDimensions arg2 ;
100394   Dali::FittingMode::Type arg3 ;
100395   Dali::SamplingMode::Type arg4 ;
100396   Dali::ImageDimensions *argp2 ;
100397   Dali::ImageDimensions result;
100398
100399   if (!jarg1) {
100400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100401     return 0;
100402   }
100403   std::string arg1_str(jarg1);
100404   arg1 = &arg1_str;
100405   argp2 = (Dali::ImageDimensions *)jarg2;
100406   if (!argp2) {
100407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100408     return 0;
100409   }
100410   arg2 = *argp2;
100411   arg3 = (Dali::FittingMode::Type)jarg3;
100412   arg4 = (Dali::SamplingMode::Type)jarg4;
100413   {
100414     try {
100415       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
100416     } catch (std::out_of_range& e) {
100417       {
100418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100419       };
100420     } catch (std::exception& e) {
100421       {
100422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100423       };
100424     } catch (...) {
100425       {
100426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100427       };
100428     }
100429   }
100430   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
100431
100432   return jresult;
100433 }
100434
100435
100436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
100437   void * jresult ;
100438   std::string *arg1 = 0 ;
100439   Dali::ImageDimensions arg2 ;
100440   Dali::FittingMode::Type arg3 ;
100441   Dali::ImageDimensions *argp2 ;
100442   Dali::ImageDimensions result;
100443
100444   if (!jarg1) {
100445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100446     return 0;
100447   }
100448   std::string arg1_str(jarg1);
100449   arg1 = &arg1_str;
100450   argp2 = (Dali::ImageDimensions *)jarg2;
100451   if (!argp2) {
100452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100453     return 0;
100454   }
100455   arg2 = *argp2;
100456   arg3 = (Dali::FittingMode::Type)jarg3;
100457   {
100458     try {
100459       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
100460     } catch (std::out_of_range& e) {
100461       {
100462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100463       };
100464     } catch (std::exception& e) {
100465       {
100466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100467       };
100468     } catch (...) {
100469       {
100470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100471       };
100472     }
100473   }
100474   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
100475
100476   return jresult;
100477 }
100478
100479
100480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
100481   void * jresult ;
100482   std::string *arg1 = 0 ;
100483   Dali::ImageDimensions arg2 ;
100484   Dali::ImageDimensions *argp2 ;
100485   Dali::ImageDimensions result;
100486
100487   if (!jarg1) {
100488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100489     return 0;
100490   }
100491   std::string arg1_str(jarg1);
100492   arg1 = &arg1_str;
100493   argp2 = (Dali::ImageDimensions *)jarg2;
100494   if (!argp2) {
100495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100496     return 0;
100497   }
100498   arg2 = *argp2;
100499   {
100500     try {
100501       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
100502     } catch (std::out_of_range& e) {
100503       {
100504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100505       };
100506     } catch (std::exception& e) {
100507       {
100508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100509       };
100510     } catch (...) {
100511       {
100512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100513       };
100514     }
100515   }
100516   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
100517
100518   return jresult;
100519 }
100520
100521
100522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
100523   void * jresult ;
100524   std::string *arg1 = 0 ;
100525   Dali::ImageDimensions result;
100526
100527   if (!jarg1) {
100528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100529     return 0;
100530   }
100531   std::string arg1_str(jarg1);
100532   arg1 = &arg1_str;
100533   {
100534     try {
100535       result = Dali::GetClosestImageSize((std::string const &)*arg1);
100536     } catch (std::out_of_range& e) {
100537       {
100538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100539       };
100540     } catch (std::exception& e) {
100541       {
100542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100543       };
100544     } catch (...) {
100545       {
100546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100547       };
100548     }
100549   }
100550   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
100551
100552   return jresult;
100553 }
100554
100555 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
100556   void * jresult ;
100557   std::string *arg1 = 0 ;
100558   Dali::ImageDimensions result;
100559
100560   if (!jarg1) {
100561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100562     return 0;
100563   }
100564   std::string arg1_str(jarg1);
100565   arg1 = &arg1_str;
100566   {
100567     try {
100568       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
100569     } catch (std::out_of_range& e) {
100570       {
100571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100572       };
100573     } catch (std::exception& e) {
100574       {
100575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100576       };
100577     } catch (...) {
100578       {
100579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100580       };
100581     }
100582   }
100583   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
100584
100585   return jresult;
100586 }
100587
100588 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
100589   void * jresult ;
100590   std::string *arg1 = 0 ;
100591   Dali::ImageDimensions arg2 ;
100592   Dali::FittingMode::Type arg3 ;
100593   Dali::SamplingMode::Type arg4 ;
100594   bool arg5 ;
100595   Dali::ImageDimensions *argp2 ;
100596   Dali::Devel::PixelBuffer result;
100597
100598   if (!jarg1) {
100599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100600     return 0;
100601   }
100602   std::string arg1_str(jarg1);
100603   arg1 = &arg1_str;
100604   argp2 = (Dali::ImageDimensions *)jarg2;
100605   if (!argp2) {
100606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100607     return 0;
100608   }
100609   arg2 = *argp2;
100610   arg3 = (Dali::FittingMode::Type)jarg3;
100611   arg4 = (Dali::SamplingMode::Type)jarg4;
100612   arg5 = jarg5 ? true : false;
100613   {
100614     try {
100615       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
100616     } catch (std::out_of_range& e) {
100617       {
100618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100619       };
100620     } catch (std::exception& e) {
100621       {
100622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100623       };
100624     } catch (...) {
100625       {
100626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100627       };
100628     }
100629   }
100630   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100631
100632   return jresult;
100633 }
100634
100635
100636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
100637   void * jresult ;
100638   std::string *arg1 = 0 ;
100639   Dali::ImageDimensions arg2 ;
100640   Dali::FittingMode::Type arg3 ;
100641   Dali::SamplingMode::Type arg4 ;
100642   Dali::ImageDimensions *argp2 ;
100643   Dali::Devel::PixelBuffer result;
100644
100645   if (!jarg1) {
100646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100647     return 0;
100648   }
100649   std::string arg1_str(jarg1);
100650   arg1 = &arg1_str;
100651   argp2 = (Dali::ImageDimensions *)jarg2;
100652   if (!argp2) {
100653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100654     return 0;
100655   }
100656   arg2 = *argp2;
100657   arg3 = (Dali::FittingMode::Type)jarg3;
100658   arg4 = (Dali::SamplingMode::Type)jarg4;
100659   {
100660     try {
100661       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
100662     } catch (std::out_of_range& e) {
100663       {
100664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100665       };
100666     } catch (std::exception& e) {
100667       {
100668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100669       };
100670     } catch (...) {
100671       {
100672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100673       };
100674     }
100675   }
100676   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100677
100678   return jresult;
100679 }
100680
100681
100682 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
100683   void * jresult ;
100684   std::string *arg1 = 0 ;
100685   Dali::ImageDimensions arg2 ;
100686   Dali::FittingMode::Type arg3 ;
100687   Dali::ImageDimensions *argp2 ;
100688   Dali::Devel::PixelBuffer result;
100689
100690   if (!jarg1) {
100691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100692     return 0;
100693   }
100694   std::string arg1_str(jarg1);
100695   arg1 = &arg1_str;
100696   argp2 = (Dali::ImageDimensions *)jarg2;
100697   if (!argp2) {
100698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100699     return 0;
100700   }
100701   arg2 = *argp2;
100702   arg3 = (Dali::FittingMode::Type)jarg3;
100703   {
100704     try {
100705       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
100706     } catch (std::out_of_range& e) {
100707       {
100708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100709       };
100710     } catch (std::exception& e) {
100711       {
100712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100713       };
100714     } catch (...) {
100715       {
100716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100717       };
100718     }
100719   }
100720   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100721
100722   return jresult;
100723 }
100724
100725
100726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
100727   void * jresult ;
100728   std::string *arg1 = 0 ;
100729   Dali::ImageDimensions arg2 ;
100730   Dali::ImageDimensions *argp2 ;
100731   Dali::Devel::PixelBuffer result;
100732
100733   if (!jarg1) {
100734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100735     return 0;
100736   }
100737   std::string arg1_str(jarg1);
100738   arg1 = &arg1_str;
100739   argp2 = (Dali::ImageDimensions *)jarg2;
100740   if (!argp2) {
100741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
100742     return 0;
100743   }
100744   arg2 = *argp2;
100745   {
100746     try {
100747       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
100748     } catch (std::out_of_range& e) {
100749       {
100750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100751       };
100752     } catch (std::exception& e) {
100753       {
100754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100755       };
100756     } catch (...) {
100757       {
100758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100759       };
100760     }
100761   }
100762   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100763
100764   return jresult;
100765 }
100766
100767
100768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
100769   void * jresult ;
100770   std::string *arg1 = 0 ;
100771   Dali::Devel::PixelBuffer result;
100772
100773   if (!jarg1) {
100774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
100775     return 0;
100776   }
100777   std::string arg1_str(jarg1);
100778   arg1 = &arg1_str;
100779   {
100780     try {
100781       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
100782     } catch (std::out_of_range& e) {
100783       {
100784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100785       };
100786     } catch (std::exception& e) {
100787       {
100788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100789       };
100790     } catch (...) {
100791       {
100792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100793       };
100794     }
100795   }
100796   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
100797
100798   return jresult;
100799 }
100800
100801
100802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
100803   void * jresult ;
100804   Dali::Toolkit::WebView result;
100805
100806   {
100807     try {
100808       result = Dali::Toolkit::WebView::New();
100809     } catch (std::out_of_range& e) {
100810       {
100811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100812       };
100813     } catch (std::exception& e) {
100814       {
100815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100816       };
100817     } catch (Dali::DaliException e) {
100818       {
100819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100820       };
100821     } catch (...) {
100822       {
100823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100824       };
100825     }
100826   }
100827   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
100828   return jresult;
100829 }
100830
100831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
100832   void * jresult ;
100833   Dali::Toolkit::WebView result;
100834
100835   std::string *arg1;
100836   std::string *arg2;
100837
100838   if (!jarg1) {
100839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
100840     return 0;
100841   }
100842   if (!jarg2) {
100843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
100844     return 0;
100845   }
100846
100847   std::string jarg1_str = std::string(jarg1);
100848   std::string jarg2_str = std::string(jarg2);
100849
100850   arg1 = &jarg1_str;
100851   arg2 = &jarg2_str;
100852
100853   {
100854     try {
100855       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
100856     } catch (std::out_of_range& e) {
100857       {
100858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100859       };
100860     } catch (std::exception& e) {
100861       {
100862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100863       };
100864     } catch (Dali::DaliException e) {
100865       {
100866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100867       };
100868     } catch (...) {
100869       {
100870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100871       };
100872     }
100873   }
100874   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
100875   return jresult;
100876 }
100877
100878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
100879   void * jresult ;
100880   Dali::Toolkit::WebView *arg1 = 0 ;
100881   Dali::Toolkit::WebView *result = 0 ;
100882
100883   arg1 = (Dali::Toolkit::WebView *)jarg1;
100884   if (!arg1) {
100885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
100886     return 0;
100887   }
100888   {
100889     try {
100890       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
100891     } catch (std::out_of_range& e) {
100892       {
100893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100894       };
100895     } catch (std::exception& e) {
100896       {
100897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100898       };
100899     } catch (Dali::DaliException e) {
100900       {
100901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100902       };
100903     } catch (...) {
100904       {
100905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100906       };
100907     }
100908   }
100909   jresult = (void *)result;
100910   return jresult;
100911 }
100912
100913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
100914   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100915   arg1 = (Dali::Toolkit::WebView *)jarg1;
100916   {
100917     try {
100918       delete arg1;
100919     } catch (std::out_of_range& e) {
100920       {
100921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
100922       };
100923     } catch (std::exception& e) {
100924       {
100925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
100926       };
100927     } catch (Dali::DaliException e) {
100928       {
100929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
100930       };
100931     } catch (...) {
100932       {
100933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
100934       };
100935     }
100936   }
100937 }
100938
100939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
100940   void * jresult ;
100941   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
100942   Dali::Toolkit::WebView *arg2 = 0 ;
100943   Dali::Toolkit::WebView *result = 0 ;
100944
100945   arg1 = (Dali::Toolkit::WebView *)jarg1;
100946   arg2 = (Dali::Toolkit::WebView *)jarg2;
100947   if (!arg2) {
100948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
100949     return 0;
100950   }
100951   {
100952     try {
100953       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
100954     } catch (std::out_of_range& e) {
100955       {
100956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100957       };
100958     } catch (std::exception& e) {
100959       {
100960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100961       };
100962     } catch (Dali::DaliException e) {
100963       {
100964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
100965       };
100966     } catch (...) {
100967       {
100968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
100969       };
100970     }
100971   }
100972   jresult = (void *)result;
100973   return jresult;
100974 }
100975
100976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
100977   void * jresult ;
100978   Dali::BaseHandle arg1 ;
100979   Dali::BaseHandle *argp1 ;
100980   Dali::Toolkit::WebView result;
100981
100982   argp1 = (Dali::BaseHandle *)jarg1;
100983   if (!argp1) {
100984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
100985     return 0;
100986   }
100987   arg1 = *argp1;
100988   {
100989     try {
100990       result = Dali::Toolkit::WebView::DownCast(arg1);
100991     } catch (std::out_of_range& e) {
100992       {
100993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
100994       };
100995     } catch (std::exception& e) {
100996       {
100997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
100998       };
100999     } catch (Dali::DaliException e) {
101000       {
101001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101002       };
101003     } catch (...) {
101004       {
101005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101006       };
101007     }
101008   }
101009   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
101010   return jresult;
101011 }
101012
101013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
101014   return (int) Dali::Toolkit::WebView::Property::URL;
101015 }
101016
101017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
101018   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
101019 }
101020
101021 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
101022   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
101023 }
101024
101025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
101026   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
101027 }
101028
101029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
101030   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
101031 }
101032
101033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
101034   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
101035 }
101036
101037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
101038   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
101039 }
101040
101041 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
101042   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
101043 }
101044
101045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
101046   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101047   std::string *arg2;
101048
101049   arg1 = (Dali::Toolkit::WebView *)jarg1;
101050
101051   if (!jarg2) {
101052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101053     return;
101054   }
101055
101056   std::string jarg2str = std::string(jarg2);
101057   arg2 = &jarg2str;
101058   {
101059     try {
101060       (arg1)->LoadUrl((std::string const &)*arg2);
101061     } catch (std::out_of_range& e) {
101062       {
101063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101064       };
101065     } catch (std::exception& e) {
101066       {
101067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101068       };
101069     } catch (Dali::DaliException e) {
101070       {
101071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101072       };
101073     } catch (...) {
101074       {
101075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101076       };
101077     }
101078   }
101079 }
101080
101081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
101082   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101083   std::string *arg2;
101084
101085   arg1 = (Dali::Toolkit::WebView *)jarg1;
101086   if (!jarg2) {
101087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101088     return;
101089   }
101090   std::string jarg2str = std::string(jarg2);
101091   arg2 = &jarg2str;
101092   {
101093     try {
101094       (arg1)->LoadHTMLString((std::string const &)*arg2);
101095     } catch (std::out_of_range& e) {
101096       {
101097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101098       };
101099     } catch (std::exception& e) {
101100       {
101101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101102       };
101103     } catch (Dali::DaliException e) {
101104       {
101105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101106       };
101107     } catch (...) {
101108       {
101109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101110       };
101111     }
101112   }
101113 }
101114
101115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
101116   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101117
101118   arg1 = (Dali::Toolkit::WebView *)jarg1;
101119   {
101120     try {
101121       (arg1)->Reload();
101122     } catch (std::out_of_range& e) {
101123       {
101124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101125       };
101126     } catch (std::exception& e) {
101127       {
101128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101129       };
101130     } catch (Dali::DaliException e) {
101131       {
101132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101133       };
101134     } catch (...) {
101135       {
101136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101137       };
101138     }
101139   }
101140 }
101141
101142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
101143   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101144
101145   arg1 = (Dali::Toolkit::WebView *)jarg1;
101146   {
101147     try {
101148       (arg1)->StopLoading();
101149     } catch (std::out_of_range& e) {
101150       {
101151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101152       };
101153     } catch (std::exception& e) {
101154       {
101155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101156       };
101157     } catch (Dali::DaliException e) {
101158       {
101159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101160       };
101161     } catch (...) {
101162       {
101163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101164       };
101165     }
101166   }
101167 }
101168
101169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
101170   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101171
101172   arg1 = (Dali::Toolkit::WebView *)jarg1;
101173   {
101174     try {
101175       (arg1)->Suspend();
101176     } catch (std::out_of_range& e) {
101177       {
101178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101179       };
101180     } catch (std::exception& e) {
101181       {
101182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101183       };
101184     } catch (Dali::DaliException e) {
101185       {
101186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101187       };
101188     } catch (...) {
101189       {
101190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101191       };
101192     }
101193   }
101194 }
101195
101196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
101197   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101198
101199   arg1 = (Dali::Toolkit::WebView *)jarg1;
101200   {
101201     try {
101202       (arg1)->Resume();
101203     } catch (std::out_of_range& e) {
101204       {
101205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101206       };
101207     } catch (std::exception& e) {
101208       {
101209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101210       };
101211     } catch (Dali::DaliException e) {
101212       {
101213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101214       };
101215     } catch (...) {
101216       {
101217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101218       };
101219     }
101220   }
101221 }
101222
101223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
101224   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101225
101226   arg1 = (Dali::Toolkit::WebView *)jarg1;
101227   {
101228     try {
101229       (arg1)->GoBack();
101230     } catch (std::out_of_range& e) {
101231       {
101232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101233       };
101234     } catch (std::exception& e) {
101235       {
101236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101237       };
101238     } catch (Dali::DaliException e) {
101239       {
101240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101241       };
101242     } catch (...) {
101243       {
101244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101245       };
101246     }
101247   }
101248 }
101249
101250 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
101251   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101252
101253   arg1 = (Dali::Toolkit::WebView *)jarg1;
101254   {
101255     try {
101256       (arg1)->GoForward();
101257     } catch (std::out_of_range& e) {
101258       {
101259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101260       };
101261     } catch (std::exception& e) {
101262       {
101263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101264       };
101265     } catch (Dali::DaliException e) {
101266       {
101267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101268       };
101269     } catch (...) {
101270       {
101271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101272       };
101273     }
101274   }
101275 }
101276
101277 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
101278   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101279   bool ret;
101280
101281   arg1 = (Dali::Toolkit::WebView *)jarg1;
101282   {
101283     try {
101284       ret = (arg1)->CanGoBack();
101285     } catch (std::out_of_range& e) {
101286       {
101287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
101288       };
101289     } catch (std::exception& e) {
101290       {
101291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
101292       };
101293     } catch (Dali::DaliException e) {
101294       {
101295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
101296       };
101297     } catch (...) {
101298       {
101299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
101300       };
101301     }
101302   }
101303   return ret;
101304 }
101305
101306 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
101307   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101308   bool ret;
101309
101310   arg1 = (Dali::Toolkit::WebView *)jarg1;
101311   {
101312     try {
101313       ret = (arg1)->CanGoForward();
101314     } catch (std::out_of_range& e) {
101315       {
101316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
101317       };
101318     } catch (std::exception& e) {
101319       {
101320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
101321       };
101322     } catch (Dali::DaliException e) {
101323       {
101324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
101325       };
101326     } catch (...) {
101327       {
101328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
101329       };
101330     }
101331   }
101332   return ret;
101333 }
101334
101335 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
101336   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101337   std::string *arg2;
101338
101339   arg1 = (Dali::Toolkit::WebView *)jarg1;
101340   if (!jarg2) {
101341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101342     return;
101343   }
101344   std::string jarg2_str = std::string(jarg2);
101345   arg2 = &jarg2_str;
101346
101347   {
101348     try {
101349       if (jarg3) {
101350         void (*handler)(char*) = (void (*)(char*)) jarg3;
101351         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
101352           handler(SWIG_csharp_string_callback(result.c_str()));
101353         });
101354       } else {
101355         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
101356       }
101357     } catch (std::out_of_range& e) {
101358       {
101359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101360       };
101361     } catch (std::exception& e) {
101362       {
101363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101364       };
101365     } catch (Dali::DaliException e) {
101366       {
101367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101368       };
101369     } catch (...) {
101370       {
101371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101372       };
101373     }
101374   }
101375 }
101376
101377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
101378 {
101379   if (!jarg2) {
101380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
101381     return;
101382   }
101383
101384   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
101385   std::string exposedObjectName = jarg2;
101386   void (*handler)(char*) = (void (*)(char*)) jarg3;
101387
101388   {
101389     try {
101390       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
101391         handler(SWIG_csharp_string_callback(message.c_str()));
101392       });
101393     } catch (std::out_of_range& e) {
101394       {
101395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101396       };
101397     } catch (std::exception& e) {
101398       {
101399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101400       };
101401     } catch (Dali::DaliException e) {
101402       {
101403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101404       };
101405     } catch (...) {
101406       {
101407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101408       };
101409     }
101410   }
101411 }
101412
101413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
101414   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101415
101416   arg1 = (Dali::Toolkit::WebView *)jarg1;
101417   {
101418     try {
101419       (arg1)->ClearHistory();
101420     } catch (std::out_of_range& e) {
101421       {
101422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101423       };
101424     } catch (std::exception& e) {
101425       {
101426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101427       };
101428     } catch (Dali::DaliException e) {
101429       {
101430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101431       };
101432     } catch (...) {
101433       {
101434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101435       };
101436     }
101437   }
101438 }
101439
101440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
101441   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101442
101443   arg1 = (Dali::Toolkit::WebView *)jarg1;
101444   {
101445     try {
101446       (arg1)->ClearCache();
101447     } catch (std::out_of_range& e) {
101448       {
101449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101450       };
101451     } catch (std::exception& e) {
101452       {
101453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101454       };
101455     } catch (Dali::DaliException e) {
101456       {
101457         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101458       };
101459     } catch (...) {
101460       {
101461         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101462       };
101463     }
101464   }
101465 }
101466
101467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
101468   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
101469
101470   arg1 = (Dali::Toolkit::WebView *)jarg1;
101471   {
101472     try {
101473       (arg1)->ClearCookies();
101474     } catch (std::out_of_range& e) {
101475       {
101476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101477       };
101478     } catch (std::exception& e) {
101479       {
101480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101481       };
101482     } catch (Dali::DaliException e) {
101483       {
101484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101485       };
101486     } catch (...) {
101487       {
101488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101489       };
101490     }
101491   }
101492 }
101493
101494 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
101495     return (Dali::Toolkit::Control *)jarg1;
101496 }
101497
101498 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
101499   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
101500   SignalConverter::WebViewPageLoadSignal* result = NULL;
101501   {
101502     try {
101503       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
101504     } catch (std::out_of_range& e) {
101505       {
101506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101507       };
101508     } catch (std::exception& e) {
101509       {
101510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101511       };
101512     } catch (Dali::DaliException e) {
101513       {
101514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101515       };
101516     } catch (...) {
101517       {
101518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101519       };
101520     }
101521   }
101522   return (void*) result;
101523 }
101524
101525 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
101526   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
101527   SignalConverter::WebViewPageLoadSignal* result = NULL;
101528   {
101529     try {
101530       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
101531     } catch (std::out_of_range& e) {
101532       {
101533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101534       };
101535     } catch (std::exception& e) {
101536       {
101537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101538       };
101539     } catch (Dali::DaliException e) {
101540       {
101541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101542       };
101543     } catch (...) {
101544       {
101545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101546       };
101547     }
101548   }
101549   return (void*) result;
101550 }
101551
101552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
101553 {
101554   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
101555   {
101556     try {
101557       delete object;
101558     } catch (std::out_of_range& e) {
101559       {
101560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101561       };
101562     } catch (std::exception& e) {
101563       {
101564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101565       };
101566     } catch (Dali::DaliException e) {
101567       {
101568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101569       };
101570     } catch (...) {
101571       {
101572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101573       };
101574     }
101575   }
101576 }
101577
101578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
101579 {
101580   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
101581   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
101582   {
101583     try {
101584       proxy->Connect(callback);
101585     } catch (std::out_of_range& e) {
101586       {
101587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101588       };
101589     } catch (std::exception& e) {
101590       {
101591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101592       };
101593     } catch (Dali::DaliException e) {
101594       {
101595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101596       };
101597     } catch (...) {
101598       {
101599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101600       };
101601     }
101602   }
101603 }
101604
101605
101606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
101607   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
101608   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
101609   {
101610     try {
101611       proxy->Disconnect(callback);
101612     } catch (std::out_of_range& e) {
101613       {
101614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101615       };
101616     } catch (std::exception& e) {
101617       {
101618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101619       };
101620     } catch (Dali::DaliException e) {
101621       {
101622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101623       };
101624     } catch (...) {
101625       {
101626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101627       };
101628     }
101629   }
101630 }
101631
101632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
101633   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
101634   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
101635   {
101636     try {
101637       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
101638     } catch (std::out_of_range& e) {
101639       {
101640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101641       };
101642     } catch (std::exception& e) {
101643       {
101644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101645       };
101646     } catch (Dali::DaliException e) {
101647       {
101648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101649       };
101650     } catch (...) {
101651       {
101652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101653       };
101654     }
101655   }
101656   return (void*) result;
101657 }
101658
101659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
101660 {
101661   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
101662   {
101663     try {
101664       delete object;
101665     } catch (std::out_of_range& e) {
101666       {
101667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101668       };
101669     } catch (std::exception& e) {
101670       {
101671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101672       };
101673     } catch (Dali::DaliException e) {
101674       {
101675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101676       };
101677     } catch (...) {
101678       {
101679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101680       };
101681     }
101682   }
101683 }
101684
101685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
101686 {
101687   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
101688   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
101689   {
101690     try {
101691       proxy->Connect(callback);
101692     } catch (std::out_of_range& e) {
101693       {
101694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101695       };
101696     } catch (std::exception& e) {
101697       {
101698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101699       };
101700     } catch (Dali::DaliException e) {
101701       {
101702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101703       };
101704     } catch (...) {
101705       {
101706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101707       };
101708     }
101709   }
101710 }
101711
101712
101713 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
101714   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
101715   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
101716   {
101717     try {
101718       proxy->Disconnect(callback);
101719     } catch (std::out_of_range& e) {
101720       {
101721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
101722       };
101723     } catch (std::exception& e) {
101724       {
101725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
101726       };
101727     } catch (Dali::DaliException e) {
101728       {
101729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
101730       };
101731     } catch (...) {
101732       {
101733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
101734       };
101735     }
101736   }
101737 }
101738
101739 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
101740   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
101741   char * jresult = SWIG_csharp_string_callback((const char *)result);
101742   return jresult;
101743 }
101744
101745 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
101746   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
101747   return result;
101748 }
101749
101750
101751 struct NativeImageSourcePtrHandle
101752 {
101753   NativeImageSourcePtr Ptr;
101754 };
101755
101756 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
101757 {
101758   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
101759   return (NativeImageInterface*)(arg1);
101760 }
101761
101762 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
101763 {
101764   void* jresult;
101765   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
101766   {
101767     try {
101768       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
101769     }
101770     catch (std::out_of_range & e) {
101771       {
101772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101773       };
101774     }
101775     catch (std::exception & e) {
101776       {
101777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101778       };
101779     }
101780     catch (Dali::DaliException e) {
101781       {
101782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101783       };
101784     }
101785     catch (...) {
101786       {
101787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101788       };
101789     }
101790   }
101791   jresult = (void *)handle;
101792   return jresult;
101793 }
101794
101795 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
101796 {
101797   void* jresult;
101798   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
101799   jresult = (void*)( handle->Ptr.Get() );
101800   return jresult;
101801 }
101802
101803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
101804   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
101805   {
101806     try {
101807       delete arg1;
101808     }
101809     catch (std::out_of_range & e) {
101810       {
101811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
101812       };
101813     }
101814     catch (std::exception & e) {
101815       {
101816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
101817       };
101818     }
101819     catch (Dali::DaliException e) {
101820       {
101821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
101822       };
101823     }
101824     catch (...) {
101825       {
101826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
101827       };
101828     }
101829   }
101830 }
101831
101832 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
101833 {
101834   void* jresult;
101835   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
101836   uint16_t* arg2 = (uint16_t*)(jarg2);
101837   uint16_t* arg3 = (uint16_t*)(jarg3);
101838   uint16_t* arg4 = (uint16_t*)(jarg4);
101839   {
101840     try {
101841       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
101842     }
101843     catch (std::out_of_range & e) {
101844       {
101845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101846       };
101847     }
101848     catch (std::exception & e) {
101849       {
101850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101851       };
101852     }
101853     catch (Dali::DaliException e) {
101854       {
101855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101856       };
101857     }
101858     catch (...) {
101859       {
101860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101861       };
101862     }
101863   }
101864   return jresult;
101865 }
101866
101867 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
101868 {
101869   bool jresult;
101870   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
101871
101872   {
101873     try {
101874       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
101875     }
101876     catch (std::out_of_range & e) {
101877       {
101878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
101879       };
101880     }
101881     catch (std::exception & e) {
101882       {
101883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
101884       };
101885     }
101886     catch (Dali::DaliException e) {
101887       {
101888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
101889       };
101890     }
101891     catch (...) {
101892       {
101893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
101894       };
101895     }
101896   }
101897   return jresult;
101898 }
101899
101900
101901 #ifdef __cplusplus
101902 }
101903 #endif
101904